Referential transparency, definiteness and unfoldability
Acta Informatica
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Report on the programming language Haskell: a non-strict, purely functional language version 1.2
ACM SIGPLAN Notices - Haskell special issue
The revised report on the syntactic theories of sequential control and state
Theoretical Computer Science
On the expressive power of programming languages
ESOP '90 Selected papers from the symposium on 3rd European symposium on programming
Observable sequentiality and full abstraction
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Call by name, assignment, and the lambda calculus
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On the orthogonality of assignments and procedures in Algol
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Imperative functional programming
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Fully abstract semantics for observably sequential languages
Information and Computation
A call-by-need lambda calculus
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Lisp and Symbolic Computation - Special issue on state in programming languages (part I)
Monadic state: axiomatization and type safety
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Assignments for Applicative Languages
Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture
Definitional interpreters for higher-order programming languages
ACM '72 Proceedings of the ACM annual conference - Volume 2
Combinatory reduction systems: introduction and survey
Combinatory reduction systems: introduction and survey
The call-by-need lambda calculus
Journal of Functional Programming
Bridging the gulf: a common intermediate language for ML and Haskell
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Correctness of monadic state: an imperative call-by-need calculus
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the fourth ACM SIGPLAN international conference on Functional programming
Macros as multi-stage computations: type-safe, generative, binding macros in MacroML
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
Eager Haskell: resource-bounded execution yields efficient iteration
Proceedings of the 2002 ACM SIGPLAN workshop on Haskell
ACM Transactions on Programming Languages and Systems (TOPLAS)
Explicitly recursive grammar combinators: a better model for shallow parser DSLs
PADL'11 Proceedings of the 13th international conference on Practical aspects of declarative languages
Higher-Order and Symbolic Computation
Hi-index | 0.00 |
Functional programming languages are informally classified into pure and impure languages. The precise meaning of this distinction has been a matter of controversy. We therefore investigate a formal definition of purity. We begin by showing that some proposed definitions which rely on confluence, soundness of the beta axiom, preservation of pure observational equivalences and independence of the order of evaluation, do not withstand close scrutiny. We propose instead a definition based on parameter-passing independence. Intuitively, the definition implies that functions are pure mappings from arguments to results; the operational decision of how to pass the arguments is irrelevant. In the context of Haskell, our definition is consistent with the fact that the traditional call-by-name denotational semantics coincides with the traditional call-by-need implementation. Furthermore, our definition is compatible with the stream-based, continuation-based and monad-based integration of computational effects in Haskell. Finally, we observe that call-by-name reasoning principles are unsound in compilers for monadic Haskell.