A theory for nondeterminism, parallelism, communication, and concurrency
Theoretical Computer Science
CML: A higher concurrent language
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
Selected papers of the Second Workshop on Concurrency and compositionality
Non-determinism in functional languages
The Computer Journal - Special issue on formal methods: part 1
An overview of Manifold and its implementation
Concurrency: Practice and Experience
A natural semantics for lazy evaluation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A call-by-need lambda calculus
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
From CML to its process algebra
Theoretical Computer Science
Let-floating: moving bindings to give faster programs
Proceedings of the first ACM SIGPLAN international conference on Functional programming
A theory of weak bisimulation for core CML
Proceedings of the first ACM SIGPLAN international conference on Functional programming
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
A non-deterministic call-by-need lambda calculus
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Improvement in a lazy context: an operational theory for call-by-need
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A transformation-based optimiser for Haskell
Science of Computer Programming - Special issue on the 6th European symposium on programming
Improvement theory and its applications
Higher order operational techniques in semantics
Towards a Semantic Theory of CML (Extended Abstract)
MFCS '95 Proceedings of the 20th International Symposium on Mathematical Foundations of Computer Science
Power Domains and Predicate Transformers: A Topological View
Proceedings of the 10th Colloquium on Automata, Languages and Programming
Nondeterministic call by need is neither lazy nor by name
LFP '82 Proceedings of the 1982 ACM symposium on LISP and functional programming
McCarthy''s Amb Cannot Implement Fair Merge
McCarthy''s Amb Cannot Implement Fair Merge
Deriving a lazy abstract machine
Journal of Functional Programming
The call-by-need lambda calculus
Journal of Functional Programming
RTA '08 Proceedings of the 19th international conference on Rewriting Techniques and Applications
Infinite Unfolding and Transformations of Nondeterministic Programs
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 1
| Hi-index | 0.01 |
The powerful abstraction mechanisms of functional programming languages provide the means to develop domain-specific programming languages within the language itself. Typically, this is realised by designing a set of combinators (higher-order reusable programs) for an application area, and by constructing individual applications by combining and coordinating individual combinators. This paper is concerned with a successful example of such an embedded programming language, namely Fudgets, a library of combinators for building graphical user interfaces in the lazy functional language Haskell. The Fudget library has been used to build a number of substantial applications, including a web browser and a proof editor interface to a proof checker for constructive type theory. This paper develops a semantic theory for the non-deterministic stream processors that are at the heart of the Fudget concept. The interaction of two features of stream processors makes the development of such a semantic theory problematic: (i) the sharing of computation provided by the lazy evaluation mechanism of the underlying host language, and (ii) the addition of non-deterministic choice needed to handle the natural concurrency that reactive applications entail. We demonstrate that this combination of features in a higher-order functional language can be tamed to provide a tractable semantic theory and induction principles suitable for reasoning about contextual equivalence of Fudgets.