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

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

A region inference algorithm

TLDR
It is proved that the algorithm is sound with respect to the region inference rules and that it always terminates even though the area inference rules permit polymorphic recursion in regions.

Effects and effect inference for a core Java calculus

A theory of stack allocation in polymorphically typed languages

TLDR
The main result of this report is that region inference is safe, a result which entails that regions really can be deallocated, when region inference says they can.

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.
...

References

SHOWING 1-10 OF 42 REFERENCES

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.

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.

A Theory of Type Polymorphism in Programming

  • R. Milner
  • Computer Science
    J. Comput. Syst. Sci.
  • 1978

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.

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.