Causal commutative arrows

Journal of Functional Programming

Volumn 21, Issue 4-5, 2011, Pages 467-496

  Liu, Hai ^a   Cheng, Eric ^a   Hudak, Paul ^a  

^a Yale University   (United States)

Author keywords

[No Author keywords available]

Indexed keywords

EID: 85009086511     PISSN: 09567968     EISSN: 14697653     Source Type: Journal    
DOI: 10.1017/S0956796811000153     Document Type: Article

References (52)

1. Amagbegnon, P., Besnard, L., & Guernic, P. L. (1995) Implementation of the data-flow synchronous language SIGNAL. In Conference on Programming Language Design and Implementation. ACM, pp. 163–173.
2. Atkey, R. (2008) What is a categorical model of arrows? In Proceedings of the Second Workshop on Mathematically Structured Functional Programming. vol. 229 pp. 19–37.
3. Bjesse, P., Claessen, K., Sheeran, M., & Singh, S. (1998) Lava: Hardware design in Haskell. In Proceedings of International Conference on Functional Programming (ICFP). ACM, pp. 174–184.
4. Burchett, K., Cooper, G. H. & Krishnamurthi, S. (2007) Lowering: A static optimization technique for transparent functional reactivity. In ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation. ACM, pp. 71–80.
5. Caspi, P., Halbwachs, N., Pilaud, D. & Plaice, J. A. (1987) LUSTRE: A declarative language for programming synchronous systems. In Proceedings of the 14th ACM Symposium on Principles of Programming Languages (POPL). ACM, pp. 178–188.
6. Caspi, P. & Pouzet, M. (1998) A co-iterative characterization of synchronous stream functions. In Coalgebraic Methods in Computer Science (CMCS). Electronic Notes in Theoretical Computer Science. Elsevier. Extended version available as a VERIMAG Tech. Rep. no. 97–07 at www.lri.fr/∼pouzet. pp. 1–21.
7. Cheng, E. & Hudak, P. (2009) Audio Processing and Sound Synthesis in Haskell. Tech. Rep. YALEU/DCS/RR-1405. Computer Science Department, Yale University, New Heaven, CT. Also see http://haskell.cs.yale.edu.
8. Cheong, M. H. (2005) Functional Programming and 3D Games. M.Phil. thesis, University of New South Wales, Sydney, Australia. Also see http://www.haskell.org/haskellwiki/Frag.
9. Colaço, J.-L., Girault, A., Hamon, G., & Pouzet, M. (2004) Towards a higher-order synchronous data-flow language. In Proceedings of the 4th ACM International Conference on Embedded Software (EMSOFT). New York: ACM, pp. 230–239.
10. Courtney, A. (2004) Modelling User Interfaces in a Functional Language. PhD thesis, Department of Computer Science, Yale University, New Heaven, CT.
11. Courtney, A. & Elliott, C. (2001) Genuinely functional user interfaces. In Proceedings of the 2001 ACM SIGPLAN Haskell Workshop. ACM, pp. 41–69.
12. Courtney, A., Nilsson, H. & Peterson, J. (2003) The Yampa arcade. In Proceedings of the 2003 ACM SIGPLAN Haskell Workshop. Uppsala, Sweden: ACM, pp. 7–18.
13. Coutts, D., Leshchinskiy, R. & Stewart, D. (2007) Stream fusion: From lists to streams to nothing at all. In Proceedings of the International Conference on Functional Programming (ICFP). ACM. pp. 315–326.
14. Elliott, C. & Hudak, P. (1997) Functional reactive animation. In Proceedings of the International Conference on Functional Programming (ICFP). ACM, pp. 263–273.
15. Giorgidze, G. & Nilsson, H. (2008) Switched-on Yampa. In Proceedings, Hudak, P. & Warren, D. S. (eds), Lecture Notes in Computer Science, vol. 4902. San Francisco, CA: Springer, pp. 282–298.
16. Goertzel, G. (1958) An algorithm for the evaluation of finite trigonometric series. Am. Math. Mon. 65(Jan.), 34–35.
17. Halbwachs, N., Raymond, P. & Ratel, C. (1991) Generating efficient code from data-flow programs. In Proceedings of the Third International Symposium on Programming Language Implementation and Logic Programming, Maluszyński, J. & Wirsing, M. (eds). Springer-Verlag, pp. 207–218.
18. Harel, D. (1980) On folk theorems. Commun. ACM 23(July), 379–389.
19. Hasegawa, M. (1997) Recursion from cyclic sharing: Traced monoidal categories and models of cyclic lambda calculi. In Proceedings of the Third International Conference on Typed Lambda Calculi and Applications (TLCA). London: Springer-Verlag, pp. 196–213.
20. Huang, L., Hudak, P. & Peterson, J. (2007) HPorter: Using arrows to compose parallel processes. In Proceedings of Practical Aspects of Declarative Languages (PADL). Springer-Verlag, pp. 275–289.
21. Hudak, P. (1996) Building domain specific embedded languages. ACM Computing Surveys, 28A, (electronic).
22. Hudak, P. (1998) Modular domain specific languages and tools. In Proceedings of Fifth International Conference on Software Reuse. IEEE Computer Society, pp. 134–142.
23. Hudak, P., Courtney, A., Nilsson, H. & Peterson, J. (2003) Arrows, robots, and functional reactive programming. In Summer School on Advanced Functional Programming (AFP 2002), Oxford University. Lecture Notes in Computer Science, vol. 2638. Springer-Verlag, pp. 159- 187.
24. Hudak, P., Liu, H., Stern, M & Agarwal, A. 2008 (July). Yampa Meets the Worm. Tech. Rep. YALEU/DCS/RR-1408. Yale University, New Heaven, CT. Also see http://haskell.cs.yale.edu.
25. Hughes, J. (2000) Generalising monads to arrows. Sci. Comput. Program. 37(1–3), 67–111.
26. Hughes, J. (2004) Programming with arrows. In Advanced Functional Programming, Vene, V. & Uustalu, T. (eds), Lecture Notes in Computer Science, vol. 3622. Springer, pp. 73–129.
27. Jansson, P. & Jeuring, J. (1999) Polytypic compact printing and parsing. In European Symposium on Programming (ESOP), Swierstra, S. D. (ed), Lecture Notes in Computer Science, vol. 1576. Springer, pp. 273–287.
28. Lindley, S., Wadler, P. & Yallop, J. (2010) The arrow calculus (functional pearl). J. Funct. Program. 20(1), 51–69.
29. Liu, H. & Hudak, P. (2007) Plugging a space leak with an arrow. Electron. Notes Theor. Comput. Sci. 193, 29–45.
30. Liu, H. & Hudak, P. (2010) An ode to arrows. In Proceedings of the 12th International Symposium on Practical Aspects of Declarative Languages (PADL), Madrid, Spain, January 18–19, 2010, Carro, M. & Peña, R. (eds), Lecture Notes in Computer Science, vol. 5937. Springer, pp. 152–166.
31. Lublinerman, R., Szegedy, C. & Tripakis, S. (2009) Modular code generation from synchronous block diagrams: Modularity vs. code size. In Proceedings of the 36th annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. POPL '09. New York: ACM, pp. 78–89.
32. Lublinerman, R. & Tripakis, S. (2008) Modularity vs. reusability: Code generation from synchronous block diagrams. In Proceedings of the Conference on Design, Automation and Test in Europe. DATE '08. New York: ACM, pp. 1504–1509.
33. McBride, C. & Paterson, R. (2008) Applicative programming with effects. J. Funct. Program. 18(1), 1–13.
34. Mealy, G. H. (1955) A method for synthesizing sequential circuits. Bell Syst. Tech. J. 34(5), 1045–1079.
35. Moggi, E. (1991) Notions of computation and monads. Inf. Comput. 93(1), 55–92.
36. Nilsson, H. (2005) Dynamic optimization for functional reactive programming using generalized algebraic data types. In Proceedings of International Conference on Functional Programming (ICFP). ACM, pp. 54–65.
37. Oertel, C. 2006 (May). RatTracker: A Functional-Reactive Approach to Flexible Control of Behavioural Conditioning Experiments. PhD thesis, Wilhelm-Schickard-Institute for Computer Science at the University of Tübingen, Tübingen, Germany.
38. Paterson, R. (2001) A new notation for arrows. In Proceedings of International Conference on Functional Programming (ICFP). ACM, pp. 229–240.
39. Peterson, J., Hager, G. & Hudak, P. (1999a) A language for declarative robotic programming. In International Conference on Robotics and Automation, IEEE pp. 1144–1151.
40. Peterson, J., Hudak, P. & Elliott, C. (1999b) Lambda in motion: Controlling robots with Haskell. In Proceedings of the First International Workshop on Practical Aspects of Declarative Languages (PADL). ACM, pp. 91–105.
41. Peyton Jones, Simon, et al. (2003) The Haskell 98 language and libraries: The revised report. J. Funct. Program. 13(1), 0–255.
42. Pouzet, M. & Raymond, P. (2009) Modular static scheduling of synchronous data flow networks: an efficient symbolic representation. In Proceedings of the seventh ACM International Conference on Embedded Software. EMSOFT '09. New York: ACM, pp. 215- 224.
43. Power, J. & Thielecke, H. (1999) Closed freyd- and kappa-categories. In Proceedings of 26th International Colloquium on Automata, Languages and Programming (ICALP), Springer-Verlag pp. 625–634.
44. Raymond, P. (1988) Compilation séparée de programmes lustre. Master's thesis. IMAG (in French).
45. Rutten, J. J. M. M. (2006) Algebraic specification and coalgebraic synthesis of mealy automata. Electron. Notes Theor. Comput. Sci., 160, 305–319.
46. Sculthorpe, N. & Nilsson, H. (2008) Optimisation of dynamic, hybrid signal function networks. In Proceedings of the 9th Symposium on Trends in Functional Programming (TFP). Intellect, pp. 97–112.
47. Sheard, T. & Peyton Jones, S. (2002) Template metaprogramming for Haskell. In Proceedings of the 2002 ACM SIGPLAN Haskell Workshop, Chakravarty, M. M. T. (ed). ACM, pp. 1–16.
48. Stephens, R. (1997) A survey of stream processing. Acta Inform. 34(7), 491–541.
49. Street, R. H., Joyal, A. & Verity, D. (1996) Traced monoidal categories. Math. Proc. Camb. Phil. Soc. 119(3), 425–446.
50. Thies, W., Karczmarek, M. & Amarasinghe, S. P. (2002) StreamIt: A language for streaming applications. In Proceedings of the 11th International Conference on Compiler Construction (CC). London: Springer-Verlag, 179–196.
51. Uustalu, T. & Vene, V. (2005) The essence of dataflow programming. In Central European Functional Programming School (CEFP), Horváth, Z. (ed), Lecture Notes in Computer Science, vol. 4164. Springer, pp. 135–167.
52. Wadge, W. W., & Ashcroft, E. A. (1985) LUCID, the Dataflow Programming Language. San Diego, CA: Academic Press Professional, Inc.