Imperative functional programming

@inproceedings{Jones1993ImperativeFP,
  title={Imperative functional programming},
  author={S. Jones and P. Wadler},
  booktitle={POPL '93},
  year={1993}
}
We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, and extends smoothly to incorporate mixed-language working and in-place array updates. 
How to declare an imperative
TLDR
This tutorial describes a solution to this problem based on a monad of interaction based on synchronous streams, continuations, linear logic, and side effects in a purely declarative language. Expand
Composable memory transactions
TLDR
This paper presents a new concurrency model, based on transactional memory, that offers far richer composition, and describes new modular forms of blocking and choice that have been inaccessible in earlier work. Expand
Reasoning About Deterministic Concurrent Functional I/O
TLDR
This paper develops a language for reasoning about concurrent functional I/O and proves that under certain conditions evaluation in this language is deterministic. Expand
Lazy functional state threads
TLDR
This work presents a way of securely encapsulating stateful computations that manipulate multiple, named, mutable objects, in the context of a non-strict, purely-functional language, using parametricity. Expand
About classical logic and imperative programming
  • J. Krivine
  • Mathematics, Computer Science
  • Annals of Mathematics and Artificial Intelligence
  • 2005
TLDR
It is shown how a λ-calculus system in second-order classical logic can modelize some aspects of imperative programming languages, such as assignment and escape instructions, by means of some simple examples. Expand
From Functional Programs to Interaction Nets via the Rewriting Calculus
We use the @r-calculus as an intermediate language to compile functional languages with pattern-matching features, and give an interaction net encoding of the @r-terms arising from the compilation.Expand
Composable memory transactions
TLDR
This paper presents a concurrency model, based on transactional memory, that offers far richer composition, and describes modular forms of blocking and choice that were inaccessible in earlier work. Expand
Variable elimination for building interpreters
TLDR
This paper builds an interpreter by reusing host language functions instead of recoding mechanisms of function application that are already available in the host language, and uses combinatory logic : lambda-abstractions are transformed into a composition of combinators. Expand
Combining Monads
TLDR
This work describes how some monads may be combined with others to yield a combined monad, a way of structuring functional programs. Expand
Directions in Functional Programming for Real(-Time) Applications
TLDR
This work addresses the use of types to classify properties of real-time computations and attempts to explain the relevance of functional programming concepts to the real- time applications domain. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 78 REFERENCES
Linearity and Laziness
TLDR
Wadler's proposal involves the use of a type system based on the linear logic of Girard that allows the programmer to specify the “natural” imperative operations without at the same time sacrificing the crucial property of referential transparency. Expand
Unboxed Values as First Class Citizens in a Non-Strict Functional Language
TLDR
The code compiled from a non-strict functional program usually manipulates heap-allocated boxed numbers and optimises operations on boxed numbers into simpler operations on their unboxed forms. Expand
A semantic model of reference counting and its abstraction (detailed summary)
Most interpreters for functional languages (as well as Lisp) employ at some level in the implementation a notion of sharing, whether manifested indirectly through an environment or directly viaExpand
The essence of functional programming
TLDR
This paper explores the use monads to structure functional programs and describes the relation between monads and the continuation-passing style in a compiler for Haskell that is written in Haskell. Expand
Integrating functional and imperative programming
TLDR
A class of programming languages that enables the advantages of functional and imperative computation to be combined within a single program, which is called fluent languages, which have distinct sublanguages forfunctional and imperative programming. Expand
Computational lambda-calculus and monads
  • E. Moggi
  • Mathematics, Computer Science
  • [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science
  • 1989
TLDR
The author gives a calculus based on a categorical semantics for computations, which provides a correct basis for proving equivalence of programs, independent from any specific computational model. Expand
Single-threaded polymorphic lambda calculus
  • J. Guzman, P. Hudak
  • Mathematics, Computer Science
  • [1990] Proceedings. Fifth Annual IEEE Symposium on Logic in Computer Science
  • 1990
The primary goal of this study is to devise a method to express mutations to state in a modern (higher order, polymorphic, nonstrict) functional language, without sacrificing referentialExpand
Detecting global variables in denotational specifications
TLDR
The criteria and transformation are useful for transforming denotational definitions into compilers and interpreters for imperative machines, for optimizing applicative programs, and for judging the suitability of semantic notations for describing imperative languages. Expand
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. Expand
Assignments for Applicative Languages
TLDR
A theoretical framework for adding assignments and dynamic data to functional languages without violating their semantic properties is proposed, and a new form of abstraction called observer is designed to encapsulate state-oriented computation from the remaining purely applicative computation. Expand
...
1
2
3
4
5
...