Let-Polymorphism and Eager Type Schemes

  title={Let-Polymorphism and Eager Type Schemes},
  author={Chuck Liang},
  • Chuck Liang
  • Published in TAPSOFT 14 April 1997
  • Computer Science
This paper presents an algorithm for polymorphic type inference involving the let construct of ML in the context of higher order abstract syntax. It avoids the polymorphic closure operation of the algorithm W of Damas and Milner by using a uniform treatment of type variables at the meta-level. The basic technique of the algorithm facilitates the declarative formulation of type inference as goal-directed proof-search in a logical frameworks setting. 

Wand ’ s Algorithm Extended For the Polymorphic ML-Let ⋆ This article is an unabridged version of the paper : On Extending Wand ’ s Algorithm to Handle Polymorphic Let

This paper details an extension to Wand’s algorithm to handle the polymorphic let (a.k.a. ML-Let) construct by extending the constraint language and by using a multi-phase unification algorithm in the constraint solving phase.

Free Variables and Subexpressions in Higher-Order Meta Logic

A new meta-level representation of subterms is developed that will allow term-rewriting systems to be formulated in a higher-order meta logic.

Compiler Construction in Higher Order Logic Programming

This paper describes a general method of compiler implementation using higher order abstract syntax and logic programming including parsing and the generation of higher order repr sentations, type checking, intermediate representation in continuatio passing style, and machine-dependent code generation.

Choices in Representation and Reduction Strategies for Lambda Terms in Intensional Contexts

This study provides insights into the preferred approaches to representing and reducing lambda terms and also exposes characteristics of computations that have a somewhat unanticipated effect on performance.

An Implementation of the Language Lambda Prolog Organized around Higher-Order Pattern Unification

A new virtual machine and compilation based scheme for the language λProlog is developed by embedding a higher-order pattern unification algorithm due to Nadathur and Linnell within the well-known Warren Abstract Machine model for Prolog.

The Metalanguage lambda-Prolog and Its Implementation

This paper identifies the features of λProlog that endow it with a capability for dealing directly with binding structure, illustrates their use and and describes methods for their implementation.

A generator for type checkers

Saga is a novel language design that enables generic algorithms as found in the C STL to be type-checked such that the correctness requirements stated in algorithm interfaces are obeyed and instantiation never fails, and turns the aims of the earlier proposal SuchThat into a concrete language design.

HM(X) type inference is CLP(X) solving

The HM(X) system is a generalization of the Hindley/Milner system parameterized in the constraint domain X, where X is defined by Constraint Handling Rules, and an inference approach where the HM(x) type inference problem is first mapped to a CLP( X) program is formalized.



Type inference in the presence of overloading, subtyping and recursive types

A unified approach to type inference in the presence of overloading and coercions based on the concept of constraint sets is presented and the decidability of type inference for the class of decomposable predicates is proved.

What are principal typings and what are they good for?

The pragmatic value of the principal typing property is demonstrated, a property distinct from ML's principal type property, by studying a type system with principal typings that provides elegant support for separate compilation, including "smartest recompilation" and incremental type inference.

Polymorphic type inference

This paper deals with type inference for parametric type systems, that is --- type systems that includesple types defied over constant types and type variables, and presents an alternative algorithm V for type inference,fundamentally different from W, which easily accommodates typecoercion and overloading, allows efficient local updates to theuser program, and is more efficient than W for implementations that allow concurrency.

Higher-order abstract syntax

Higher-order abstract syntax incorporates name binding information in a uniform and language generic way and acts as a powerful link integrating diverse tools in program manipulation and other formal systems where matching and substitution or unification are central operations.

Extended natural semantics

  • J. Hannan
  • Computer Science
    Journal of Functional Programming
  • 1993
Abstract We extend the definition of natural semantics to include simply typed λ-terms, instead of first-order terms, for representing programs, and to include inference rules for the introduction

A Framework for De ning LogicsRobert Harper

The Edinburgh Logical Framework provides a means to deene (or present) logics via a new principle, the judgements as types principle, whereby each judgement is identiied with the type of its proofs.

Meta-Programming in Logic Progamming

A meta-program, regardless of the nature of the programming language, is a program whose data denotes another (object) program, and when used in artificial intelligence often formalises some knowledge.

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

A framework for defining logics

The Edinburgh Logical Framework provides a means to define (or present) logics through a general treatment of syntax, rules, and proofs by means of a typed λ-calculus with dependent types, whereby each judgment is identified with the type of its proofs.

A Declarative Alternative to "Assert" in Logic Programming

A new construct rule is proposed, which combines the declarative semantics of implication with some of the power of assert, and allows the natural andDeclarative formulation of a whole class of logic programs which previously required assert.