Polymorphic type, region and effect inference

@article{Talpin1992PolymorphicTR,
  title={Polymorphic type, region and effect inference},
  author={Jean-Pierre Talpin and Pierre Jouvelot},
  journal={Journal of Functional Programming},
  year={1992},
  volume={2},
  pages={245 - 271}
}
We present a new static system which reconstructs the types, regions and effects of expressions in an implicitly typed functional language that supports imperative operations on reference values. [] Key Method We present a reconstruction algorithm that computes the types and effects of expressions, and assigns regions to reference values. We prove the correctness of the reconstruction algorithm with respect to the static semantics. Finally, we discuss potential applications of our system to automatic stack…
The type and effect discipline
  • J. TalpinP. Jouvelot
  • Geology
    [1992] Proceedings of the Seventh Annual IEEE Symposium on Logic in Computer Science
  • 1992
TLDR
The type and effect discipline, a framework for reconstructing the principal type and the minimal effect of expressions in implicitly typed polymorphic functional languages that support imperative constructs, is introduced and outperforms other polymorphic type systems.
Implementation of the typed call-by-value λ-calculus using a stack of regions
TLDR
The translation is proved correct with respect to a store semantics, which models as a region-based run-time system for polymorphically typed call-by-value λ-calculus.
Region and effect inference for safe parallelism
In this paper, we present the first full regions-and-effects inference algorithm for explicitly parallel fork-join programs. We infer annotations equivalent to those in Deterministic Parallel Java
Technical Report: Region and Effect Inference for Safe Parallelism
TLDR
This paper infer annotations inspired by Deterministic Parallel Java (DPJ) for a type-safe subset of C++ for explicitly parallel fork-join programs and expresses the inference as a constraint satisfaction problem and develops, implement, and evaluate an algorithm for solving it.
Region and Effect Inference for Safe Parallelism (T)
TLDR
This paper infer annotations inspired by Deterministic Parallel Java (DPJ) for a type-safe subset of C++ that gives strong safety guarantees and expresses the inference as a constraint satisfaction problem and develops, implement, and evaluate an algorithm for solving it.
Type inference and optimisation for an impure world
TLDR
It is argued that it is more important for a compiler to be able to reason about the behaviour of a program, than for the language to be purely functional in a formal sense.
nu-Types for Effects and Freshness Analysis
We define a type and effect system for a λ -calculus extended with side effects, in the form of primitives for creating and accessing resources. The analysis correctly over-approximates the sequences
Effects and effect inference for a core Java calculus
On regions and linear types (extended abstract)
TLDR
Two different interpretations of lineartypes are used, one in which multiple-use values are freely copied and discarded and one inWhich multiple- use values are explicitly reference-counted, and it is shown that both interpretations give rise to interesting invariants for manipulating regions.
Stratified operational semantics for safety and correctness of the region calculus
TLDR
A novel approach for proving safety and correctness of a simplified version of the region calculus, composed of a highlevel semantics dealing with the conceptual difficulties of effect annotations, and a low-level one with explicit operations on a region-indexed store.
...
...

References

SHOWING 1-10 OF 35 REFERENCES
Types and Effects Towards the Integration of Functional and Imperative Programming.
TLDR
The type and effect system makes it possible to embed functional program fragments within imperative programs, and vice versa, while retaining the benefits of the chosen programming style in each program fragment, and offers a clean solution to the problem of first-class polymorphism in an imperative language.
On determining lifetime and aliasing of dynamically allocated data in higher-order functional specifications
TLDR
The goal is validate program transformations that introduce imperative constructs such as destructive updatings, stack allocations and explicit deallocations in order to reduce the run-time memory management overhead.
Algebraic reconstruction of types and effects
TLDR
This paper presents the rst algorithm for reconstructing the types and e ects of expressions in the presence of rst class procedures in a polymorphic typed language and proves that it is sound and complete, and discusses its practical import.
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 via
Polymorphic type inference and assignment
TLDR
The type system given here leads to a better integration of imperative programming style with the purely applicative kernel of ML, and generic functions that allocate mutable data can safely be given fully polymorphic types.
Static dependent types for first class modules
TLDR
Experience with an implementation of a new type system, built as an extension to the FX-87 programming language, shows that static dependent types can be used for building large systems.
Data Flow Analysis for Procedural Languages
TLDR
A language independent formulation of the problem, an interprocedural data flow algorithm, and a proof that the algorithm is correct are included, and several widespread assumptions become false or ambiguous.
Detecting conflicts between structure accesses
TLDR
This paper describes a dataflow computation that produces a conservative description of the aliases visible at any point in a program that shows how alias graphs can be used to detect potential conflicts.
The essence of ML
TLDR
It is proved that the important programming features of ML cannot be added to any impredicative language, such as the Girard-Reynolds calculus, without implicitly assuming a type of all types.
...
...