• Corpus ID: 37661588

Functional programming and input/output

@inproceedings{Gordon1992FunctionalPA,
  title={Functional programming and input/output},
  author={Andrew D. Gordon},
  year={1992}
}
  • A. Gordon
  • Published 27 January 1995
  • Computer Science
A common attraction to functional programming is the ease with which proofs can be given of program properties. A common disappointment with functional programming is the difficulty of expressing input/output (I/O) while at the same time being able to verify programs. Here, the author shows how a theory of functional programming can be smoothly extended to admit both an operational semantics for functional I/O and verification of programs engaged in I/O. He obtains, for the first time… 

Tables from this paper

Approaches to Functional I/O
TLDR
This paper discusses the approaches used by three well-known functional languages, OCaml, Haskell and Clean, and discusses the key issues raised by their use, by implementing a demonstration program in each language.
The Ins and Outs of Clean I/O
TLDR
This paper shows that I/O can be incorporated in a functional programming language without loss of any of the generally accepted advantages of functional programming languages.
Proving correctness of modular functional programs
TLDR
This dissertation shows how to provide a system for proving the correctness of large programs written in a major functional programming language, ML, and gives a method of proving correctness of ML Modules programs using the well-known data reification method.
An operational semantics for I/O in a lazy functional language
TLDR
The main result is the first formal proof of semantic equivalence of the three mechanisms of synchronised-stream, continuationpassing and Lanolin-stream 1/0, generalizing an informal argument of the Haskell committee.
Input/output in functional languages : using algebraic uniontTypes
TLDR
This thesis will show that it is possible to add a new type construction that can combine algebraic data types in untagged unions, and it will be shown that using these type rules the intuitive notion of unions being commutative, associative and idempotent are preserved.
Calculi for functional programming languages with assignment
TLDR
This dissertation extends and correct the work of Odersky, Rabin, and Hudak giving an untyped lambda-calculus as a formalism for designing functional programming languages having assignable variables and proves the consistency and suitability for implementation of the two calculi.
Functions, frames, and interactions - completing a λ-calculus-based purely functional language with respect to programming in the large and interactions with runtime environments
TLDR
This dissertation presents a simple language design that concludes that modules, objects and other language constructs for modular programming need only be provided as built-in features in languages which are restricted in their support for general abstraction, and argues that the weaknesses found to exist in other languages can be avoided by consistently following the design principles.
A functional specification of effects
TLDR
This dissertation provides pure, functional specifications in Haskell of several different effects that may be used to write and verify effectful programs in the framework of type theory, and overcomes this limitation, by presenting total functional species in Agda, a programming language with dependent types.
The Ins and Outs of Clean I / O PETER ACHTEN AND RINUS PLASMEIJER
TLDR
This paper shows that I/O can be incorporated in a functional programming language without loss of any of the generally accepted advantages of functional programming languages.
Modelling deterministic concurrent I/O
TLDR
A modified state transformer is developed which lets us mathematically model the API, then investigate and machine verify some broad conditions under which confluence holds, which are used as the basis for a small deterministic Haskell language extension called CURIO, which enforces determinism using runtime checks.
...
...

References

SHOWING 1-10 OF 148 REFERENCES
Equivalence in Functional Languages with Effects
TLDR
This paper shows that adding objects with memory to the call-by-value lambda calculus results in a language with a rich equational theory, satisfying many of the usual laws, providing evidence that expressive, mathematically clean programming languages are indeed possible.
On the Expressiveness of Purely Functional I/O Systems
TLDR
A series of surprisingly simple translations between the three models of I/O are given, demonstrating that they are not as diierent as their programming styles suggest, and implying that the styles could be mixed within a single program.
An operational semantics for I/O in a lazy functional language
TLDR
The main result is the first formal proof of semantic equivalence of the three mechanisms of synchronised-stream, continuationpassing and Lanolin-stream 1/0, generalizing an informal argument of the Haskell committee.
High Level Specification of I/O in Functional Languages
TLDR
A new solution for the I/O problem which is incorporated in the language Concurrent Clean and can in principle be applied for any other functional language as well provided that it actually uses graph rewriting semantics in the implementation.
A Theory of Type Polymorphism in Programming
  • R. Milner
  • Computer Science
    J. Comput. Syst. Sci.
  • 1978
A Syntactic Theory of Sequential State
Semantics of programming languages - structures and techniques
Semantics of Programming Languages exposes the basic motivations and philosophy underlying the applications of semantic techniques in computer science. It introduces the mathematical theory of
Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs
TLDR
A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules; these systems have semantics loosely coupled to states—only one state transition occurs per major computation.
Operational Theories of Improvement in Functional Languages (Extended Abstract)
TLDR
The main results of this paper build on Howe's study of equality in lazy computation systems and show that any improvement relation which satisfies a simple monotonicity condition with respect to the rules of the operational semantics has the desired congruence property.
Lazy functional languages - abstract interpretation and compilation
  • G. Burn
  • Computer Science
    Research monographs in parallel and distributed computing
  • 1991
TLDR
A more efficient implementation model is described that can be used when information is known about how functions use their arguments, and a semantically sound analysis technique called abstract interpretation is developed, which can determine this information, and how to use the information to compile more efficient code for sequential and parallel machines.
...
...