## Reasoning about Functions with Effects (1997)

Venue: | See Gordon and Pitts |

Citations: | 13 - 1 self |

### BibTeX

@INPROCEEDINGS{Talcott97reasoningabout,

author = {Carolyn Talcott},

title = {Reasoning about Functions with Effects},

booktitle = {See Gordon and Pitts},

year = {1997},

pages = {347--390},

publisher = {University Press}

}

### OpenURL

### Abstract

ing and using (L-unif) we have that any two lambdas that are everywhere undefined are equivalent. The classic example of an everywhere undefined lambda is Bot 4 = x:app(x:app(x; x); x:app(x; x)) In f , another example of an everywhere undefined lambda is the "do-forever" loop. Do 4 = f:Yv(Dox:Do(f(x)) By the recursive definition, for any lambda ' and value v Do(')(v) \Gamma!Ø Do(')('(v)) Reasoning about Functions with Effects 21 In f , either '(v) \Gamma!Ø v 0 for some v 0 or '(v) is undefined. In the latter case the computation is undefined since the redex is undefined. In the former case, the computation reduces to Do(')(v 0 ) and on we go. The argument for undefinedness of Bot relies only on the (app) rule and will be valid in any uniform semantics. In contrast the argument for undefinedness of Do(') relies on the (fred.isdef) property of f . Functional Streams We now illustrate the use of (L-unif-sim) computation to reason about streams represented as functions ...

### Citations

539 | A Syntactic Approach to Type Soundness
- Wright, Felleisen
- 1994
(Show Context)
Citation Context ...f Felleisen (1987) that was published in (Felleisen and Hieb 1992). Other successful uses of the technique include: the type soundness proof, via subject reduction, for the imperative ML type system (=-=Felleisen and Wright 1991-=-); the analysis of parameter passing in Algol (Crank and Felleisen 1991; Weeks and Felleisen 1993); and the analysis of reduction calculi for Scheme-like languages (Sabry and Felleisen 1993; Fields an... |

440 | Computational lambda-calculus and monads
- Moggi
- 1989
(Show Context)
Citation Context ... sense that they are not invalidated by addition of new primitive operations to the language (subject to minimal constraints on the semantics). They include the laws of computational lambda calculus (=-=Moggi 1988-=-), and the program calculi developed in (Felleisen 1987; Felleisen and Hieb 1992) for Scheme-like languages. These laws typically have simple computational justifications. For example, two expressions... |

330 | The mechanical evaluation of expressions - Landin - 1964 |

299 | Definitional interpreters for higher-order programming languages - Reynolds - 1972 |

257 | The revised report on the syntactic theories of sequential control and state. Theoretical Computer Science 103
- Felleisen, Hieb
- 1992
(Show Context)
Citation Context ...mputation). Felleisen (1987) studies reduction calculi extending the call-by-value lambda calculus to languages with control and assignment abstractions. These calculi are simplified and extended in (=-=Felleisen and Hieb 1989-=-). The notion of computational monad as a framework for axiomatizing features of programming languages is introduced in (Moggi 1989, 1990). Reduction calculi and operational equivalence both provide a... |

245 |
Combinatory reduction systems
- Klop
- 1980
(Show Context)
Citation Context ...ics. The idea of using such meta terms to specify classes of rules giving rise to reduction relations with special properties was used in (Aczel 1978) to prove a general Church-Rosser theorem and in (=-=Klop 1980-=-) to develop the theory of Combinatory Reduction Systems. Meta terms are also used in describing a unification procedure for higher-order patterns in (Nipkow 1991). As discussed above, Mason and Talco... |

239 | The lazy lambda calculus - Abramsky - 1990 |

228 | Domain theory in logical form - Abramsky - 1991 |

222 | A foundation for actor computation - Agha, Mason, et al. - 1997 |

186 | The call-by-need lambda calculus
- Ariola, Felleisen
- 1997
(Show Context)
Citation Context ...r successful uses of the technique include: the type soundness proof, via subject reduction, for the imperative ML type system (Felleisen and Wright 1991); the analysis of parameter passing in Algol (=-=Crank and Felleisen 1991-=-; Weeks and Felleisen 1993); and the analysis of reduction calculi for Scheme-like languages (Sabry and Felleisen 1993; Fields and Sabry 1993). Much work has been done to develop methods for reasoning... |

179 |
The next 700 programming languages
- Landin
- 1966
(Show Context)
Citation Context ...ombination of control and memory effects, and developing the semantic theory in a more abstract setting to better capture the essential features of program equivalence. We adopt the view proposed in (=-=Landin 1966-=-) that a programming language consists of expressions of the lambda calculus augmented with primitive operations. We call such languages -languages. The primitive operations that we have in mind inclu... |

171 | Call-by-name, call-by-value, and the lambda calculus - Plotkin - 1975 |

165 | An Abstract View of Programming Languages - Moggi - 1989 |

161 | Reasoning about programs in continuation-passing style
- Sabry, Felleisen
- 1993
(Show Context)
Citation Context ...e system (Felleisen and Wright 1991); the analysis of parameter passing in Algol (Crank and Felleisen 1991; Weeks and Felleisen 1993); and the analysis of reduction calculi for Scheme-like languages (=-=Sabry and Felleisen 1993-=-; Fields and Sabry 1993). Much work has been done to develop methods for reasoning about operational approximation and equivalence: Abramsky (1990, 1991); Bloom (1990); Egidi, Honsell, and Ronchi dell... |

128 | Lambda Calculus Models of Programming Languages - Morris - 1968 |

124 |
Higher-order critical pairs
- Nipkow
- 1991
(Show Context)
Citation Context ...a general Church-Rosser theorem and in (Klop 1980) to develop the theory of Combinatory Reduction Systems. Meta terms are also used in describing a unification procedure for higher-order patterns in (=-=Nipkow 1991-=-). As discussed above, Mason and Talcott (1989, 1991a) introduced the ciu characterization of operational equivalence which is a form of context lemma for imperative languages. The uniform computation... |

120 | Bisimilarity as a theory of functional programming - Gordon - 1995 |

118 | Observable properties of higher order functions that dynamically create local names, or What’s new - Pitts, Stark - 1993 |

111 | Equivalence in functional languages with effects
- Mason, Talcott
- 1991
(Show Context)
Citation Context ...expressive power of functions with effects and to develop rich equational theories for such languages. We extend our previous work on semantics of imperative functional languages (Talcott 1985, 1992; =-=Mason and Talcott 1991-=-a, 1992; Honsell, Mason, Smith, and Talcott 1995) by treating the combination of control and memory effects, and developing the semantic theory in a more abstract setting to better capture the essenti... |

110 | Operational reasoning in functions with local state - Pitts, Stark - 1998 |

106 | Proving congruence of bisimulation in functional programming languages - Howe - 1996 |

90 |
Revised report on the algorithmic language scheme
- Rees, Clinger
- 1986
(Show Context)
Citation Context ...nuation, and applies v to this continuation at the top level. ncc is called C in (Felleisen and Friedman 1986; Felleisen 1987). ncc differs from the Scheme call/cc primitive (Steele and Sussman 1975; =-=Rees and Clinger 1986-=-) in that call/cc evaluates the application of v to the captured continuation in the context of that continuation rather than discarding it. call/cc can be defined using ncc as follows. call/cc 4 = f:... |

83 |
Control operators, the SECD machine and the -calculus
- Felleisen, Friedman
- 1986
(Show Context)
Citation Context ...as operations O c = O f [ fnccg. 22 Talcott Roughly speaking, ncc(v) captures the current reduction context as a continuation, and applies v to this continuation at the top level. ncc is called C in (=-=Felleisen and Friedman 1986-=-; Felleisen 1987). ncc differs from the Scheme call/cc primitive (Steele and Sussman 1975; Rees and Clinger 1986) in that call/cc evaluates the application of v to the captured continuation in the con... |

75 | Scheme: An interpreter for extended lambda calculus
- Sussman, Jr, et al.
- 1998
(Show Context)
Citation Context ...uction context as a continuation, and applies v to this continuation at the top level. ncc is called C in (Felleisen and Friedman 1986; Felleisen 1987). ncc differs from the Scheme call/cc primitive (=-=Steele and Sussman 1975-=-; Rees and Clinger 1986) in that call/cc evaluates the application of v to the captured continuation in the context of that continuation rather than discarding it. call/cc can be defined using ncc as ... |

55 | Towards a theory of actor computation - Agha, Mason, et al. - 1992 |

48 | A variable typed logic of effects - Honsell, Mason, et al. - 1995 |

46 |
Fully abstract models of typed -calculi
- Milner
- 1977
(Show Context)
Citation Context ...er of contexts to be considered); and (bi)simulation relations (alternative characterizations or approximations based on co-inductively defined relations). An early example is Milner's context lemma (=-=Milner 1977-=-) which greatly simplifies the proof of operational equivalence in the case of the typed lambda calculus by reducing the contexts to be considered to a simple chain of applications. Talcott (1985) stu... |

42 | The Lazy Lambda Calculus: An Investigation into the Foundations of Functional Programming - Ong - 1988 |

38 | A general Church-Rosser theorem - Aczel - 1978 |

36 | From operational semantics to domain theory - Mason, Smith, et al. - 1996 |

35 |
Action Semantics. Number 26
- Mosses
- 1992
(Show Context)
Citation Context ...range of -languages. Operations are given semantics by reduction rules that are not modified when new features are added to the language. This kind of modularity is in the spirit of action semantics (=-=Mosses 1992-=-). The objective of action semantics is to support modular (compositional) specification of the semantics of a language allowing each feature to be specified independently, and allowing new features t... |

33 |
The Calculi of lambda-v-cs Conversion: A Syntactic Theory of Control and State in Imperative Higher-Order Programming Languages
- Felleisen
- 1987
(Show Context)
Citation Context ... new primitive operations to the language (subject to minimal constraints on the semantics). They include the laws of computational lambda calculus (Moggi 1988), and the program calculi developed in (=-=Felleisen 1987-=-; Felleisen and Hieb 1992) for Scheme-like languages. These laws typically have simple computational justifications. For example, two expressions are equivalent if they reduce to a common expression (... |

32 | Reasoning about local variables with operationally-based logical relations. LICS - Pitts - 1996 |

27 | A theory of binding structures and applications to rewriting - Talcott - 1993 |

26 | Programming, transforming, and proving with function abstractions and memories
- Mason, Talcott
- 1989
(Show Context)
Citation Context ...ating messy isomorphism considerations, to deal with arbitrary choice of names of newly allocated structures, it also was a key step leading to the formulation of the ciu theorem, first presented in (=-=Mason and Talcott 1989-=-). In 1987, Mason realized that it provided the ideal notion of a normal form and symbolic evaluation needed in the completeness result presented in (Mason and Talcott 1992). Syntactic reduction syste... |

26 | Inferring the equivalence of functional program that mutate data, Theoretical Computer Science 105
- Mason, Talcott
- 1992
(Show Context)
Citation Context ...heorem, first presented in (Mason and Talcott 1989). In 1987, Mason realized that it provided the ideal notion of a normal form and symbolic evaluation needed in the completeness result presented in (=-=Mason and Talcott 1992-=-). Syntactic reduction systems provided the basis for the elegant revision of the imperative calculi of Felleisen (1987) that was published in (Felleisen and Hieb 1992). Other successful uses of the t... |

23 |
The Semantics of Destructive Lisp
- Mason
- 1986
(Show Context)
Citation Context ...rimitives and reasoning principles. Many more examples of programming and proving with functions, control, and memory can be found in (Burge 1975); (Talcott 1985 1989, 1992); (Felleisen 1987, 1988); (=-=Mason 1986-=-); (Mason and Talcott 1990, 1991a, 1991b, 1992, 1994a, 1994b). Examples include: higher-order functionals as generic program modules; manipulating mutable lists; stream processing; co-routines; and ob... |

20 | Full abstraction and the context lemma - Jim, Meyer - 1997 |

15 | A fully abstract translation between a -calculus with reference types and Standard ML - Ritter, Pitts - 1995 |

13 | V-CS: an extended -calculus for Scheme - Felleisen - 1988 |

12 | Reasoning about explicit and implicit representations of state
- Sabry, Field
- 1993
(Show Context)
Citation Context ...ight 1991); the analysis of parameter passing in Algol (Crank and Felleisen 1991; Weeks and Felleisen 1993); and the analysis of reduction calculi for Scheme-like languages (Sabry and Felleisen 1993; =-=Fields and Sabry 1993-=-). Much work has been done to develop methods for reasoning about operational approximation and equivalence: Abramsky (1990, 1991); Bloom (1990); Egidi, Honsell, and Ronchi della Rocca (1992); Howe (1... |

12 | Verification of programs that destructively manipulate data - Mason - 1988 |

11 | Reasoning about programs with effects
- Mason, Talcott
- 1990
(Show Context)
Citation Context ...reasoning principles. Many more examples of programming and proving with functions, control, and memory can be found in (Burge 1975); (Talcott 1985 1989, 1992); (Felleisen 1987, 1988); (Mason 1986); (=-=Mason and Talcott 1990-=-, 1991a, 1991b, 1992, 1994a, 1994b). Examples include: higher-order functionals as generic program modules; manipulating mutable lists; stream processing; co-routines; and objects as functions (lambda... |

9 | Can LCF be topped - Bloom - 1990 |

9 |
The Essence of Rum: A Theory of the Intensional and Extensional Aspects of Lisp-type Computation
- Talcott
- 1985
(Show Context)
Citation Context ...low one to have the expressive power of functions with effects and to develop rich equational theories for such languages. We extend our previous work on semantics of imperative functional languages (=-=Talcott 1985-=-, 1992; Mason and Talcott 1991a, 1992; Honsell, Mason, Smith, and Talcott 1995) by treating the combination of control and memory effects, and developing the semantic theory in a more abstract setting... |

9 | A theory for program and data type specification - Talcott - 1992 |

8 |
Stream processing functions
- Burge
- 1975
(Show Context)
Citation Context ... examples to provide basic intuitions about the various program primitives and reasoning principles. Many more examples of programming and proving with functions, control, and memory can be found in (=-=Burge 1975-=-); (Talcott 1985 1989, 1992); (Felleisen 1987, 1988); (Mason 1986); (Mason and Talcott 1990, 1991a, 1991b, 1992, 1994a, 1994b). Examples include: higher-order functionals as generic program modules; m... |

7 | Program transformation via contextual assertions - Mason, Talcott - 1994 |

6 | Program transformations for configuring components - Mason, Talcott - 1991 |

5 | Action semantics reasoning about functional programs
- Lassen
- 1997
(Show Context)
Citation Context ...tations. Action semantics treats a wider range of languages, and provides a number of generic tools. However, development of equational theories derived from action semantics has only recently begun (=-=Lassen 1995-=-b) (see below). The fact that one can present a syntactic reduction system for imperative -calculi was discovered independently in 1986-1987: by Talcott (Mason and Talcott 1991a), and by Felleisen and... |