scholarly journals Principal Type Inference for GHC-Style Multi-parameter Type Classes

2006 ◽  
pp. 26-43 ◽  
Author(s):  
Martin Sulzmann ◽  
Tom Schrijvers ◽  
Peter J. Stuckey
Keyword(s):  
Type Inference ◽  
Principal Type ◽  
Type Classes

Type Inference: Some Results, Some Problems1

1993 ◽  
Vol 19 (1-2) ◽  
pp. 87-125
Author(s):  
Paola Giannini ◽  
Furio Honsell ◽  
Simona Ronchi Della Rocca
Keyword(s):  
Large Class ◽  
Higher Order ◽  
Type Inference ◽  
Principal Type ◽  
Open Problems ◽  
Inference Problem ◽  
Type Assignment ◽  
Unification Problem

In this paper we investigate the type inference problem for a large class of type assignment systems for the λ-calculus. This is the problem of determining if a term has a type in a given system. We discuss, in particular, a collection of type assignment systems which correspond to the typed systems of Barendregt’s “cube”. Type dependencies being shown redundant, we focus on the strongest of all, Fω, the type assignment version of the system Fω of Girard. In order to manipulate uniformly type inferences we give a syntax directed presentation of Fω and introduce the notions of scheme and of principal type scheme. Making essential use of them, we succeed in reducing the type inference problem for Fω to a restriction of the higher order semi-unification problem and in showing that the conditional type inference problem for Fω is undecidable. Throughout the paper we call attention to open problems and formulate some conjectures.

scholarly journals How to make ad hoc proof automation less ad hoc

2013 ◽  
Vol 23 (4) ◽  
pp. 357-401 ◽  
Author(s):  
GEORGES GONTHIER ◽  
BETA ZILIANI ◽  
ALEKSANDAR NANEVSKI ◽  
DEREK DREYER
Keyword(s):  
Design Patterns ◽  
Ad Hoc ◽  
Type System ◽  
Type Inference ◽  
Interactive Theorem Provers ◽  
Proof Automation ◽  
Novel Approach ◽  
Type Classes ◽  
Structure Programming ◽  
Base Logic

AbstractMost interactive theorem provers provide support for some form of user-customizable proof automation. In a number of popular systems, such as Coq and Isabelle, this automation is achieved primarily through tactics, which are programmed in a separate language from that of the prover's base logic. While tactics are clearly useful in practice, they can be difficult to maintain and compose because, unlike lemmas, their behavior cannot be specified within the expressive type system of the prover itself.We propose a novel approach to proof automation in Coq that allows the user to specify the behavior of custom automated routines in terms of Coq's own type system. Our approach involves a sophisticated application of Coq's canonical structures, which generalize Haskell type classes and facilitate a flexible style of dependently-typed logic programming. Specifically, just as Haskell type classes are used to infer the canonical implementation of an overloaded term at a given type, canonical structures can be used to infer the canonical proof of an overloaded lemma for a given instantiation of its parameters. We present a series of design patterns for canonical structure programming that enable one to carefully and predictably coax Coq's type inference engine into triggering the execution of user-supplied algorithms during unification, and we illustrate these patterns through several realistic examples drawn from Hoare Type Theory. We assume no prior knowledge of Coq and describe the relevant aspects of Coq type inference from first principles.

scholarly journals Type Reconstruction for Type Classes

1995 ◽  
Vol 5 (2) ◽  
pp. 201-224 ◽  
Author(s):  
Tobias Nipkow ◽  
Christian Prehofer
Keyword(s):  
Programming Language ◽  
Functional Programming ◽  
Type Inference ◽  
Constraint Solving ◽  
Simple Type ◽  
Inference Problem ◽  
Unification Algorithm ◽  
Type Classes ◽  
Type Reconstruction ◽  
Inference Systems

AbstractWe study the type inference problem for a system with type classes as in the functional programming language Haskell. Type classes are an extension of ML-style polymorphism with overloading. We generalize Milner's work on polymorphism by introducing a separate context constraining the type variables in a typing judgement. This leads to simple type inference systems and algorithms which closely resemble those for ML. In particular, we present a new unification algorithm which is an extension of syntactic unification with constraint solving. The existence of principal types follows from an analysis of this unification algorithm.

Type classes with existential types

1996 ◽  
Vol 6 (3) ◽  
pp. 485-518 ◽  
Author(s):  
Konstantin Läufer
Keyword(s):  
Formal Semantics ◽  
Type System ◽  
Expressive Power ◽  
Type Inference ◽  
The Novel ◽  
Data Types ◽  
Type Classes ◽  
Algebraic Data Types ◽  
A Minor ◽  
Existential Quantification

AbstractWe argue that the novel combination of type classes and existential types in a single language yields significant expressive power. We explore this combination in the context of higher-order functional languages with static typing, parametric polymorphism, algebraic data types and Hindley–Milner type inference. Adding existential types to an existing functional language that already features type classes requires only a minor syntactic extension. We first demonstrate how to provide existential quantification over type classes by extending the syntax of algebraic data type definitions, and give examples of possible uses. We then develop a type system and a type inference algorithm for the resulting language. Finally, we present a formal semantics by translation to an implicitly-typed second-order λ-calculus and show that the type system is semantically sound. Our extension has been implemented in the Chalmers Haskell B. system, and all examples from this paper have been developed using this system.

scholarly journals OutsideIn(X) Modular type inference with local assumptions

2011 ◽  
Vol 21 (4-5) ◽  
pp. 333-412 ◽  
Author(s):  
DIMITRIOS VYTINIOTIS ◽  
SIMON PEYTON JONES ◽  
TOM SCHRIJVERS ◽  
MARTIN SULZMANN
Keyword(s):  
General Framework ◽  
Type System ◽  
Type Inference ◽  
Inference Algorithm ◽  
System Specification ◽  
Program Correctness ◽  
Constraint Solver ◽  
Empirical Results ◽  
Local Type ◽  
Type Classes

AbstractAdvanced type system features, such as GADTs, type classes and type families, have proven to be invaluable language extensions for ensuring data invariants and program correctness. Unfortunately, they pose a tough problem for type inference when they are used as local type assumptions. Local type assumptions often result in the lack of principal types and cast the generalisation of local let-bindings prohibitively difficult to implement and specify. User-declared axioms only make this situation worse. In this paper, we explain the problems and – perhaps controversially – argue for abandoning local let-binding generalisation. We give empirical results that local let generalisation is only sporadically used by Haskell programmers. Moving on, we present a novel constraint-based type inference approach for local type assumptions. Our system, called OutsideIn(X), is parameterised over the particular underlying constraint domain X, in the same way as HM(X). This stratification allows us to use a common metatheory and inference algorithm. OutsideIn(X) extends the constraints of X by introducing implication constraints on top. We describe the strategy for solving these implication constraints, which, in turn, relies on a constraint solver for X. We characterise the properties of the constraint solver for X so that the resulting algorithm only accepts programs with principal types, even when the type system specification accepts programs that do not enjoy principal types. Going beyond the general framework, we give a particular constraint solver for X = type classes + GADTs + type families, a non-trivial challenge in its own right. This constraint solver has been implemented and distributed as part of GHC 7.

Understanding functional dependencies via constraint handling rules

2007 ◽  
Vol 17 (1) ◽  
pp. 83-129 ◽  
Author(s):  
MARTIN SULZMANN ◽  
GREGORY J. DUCK ◽  
SIMON PEYTON-JONES ◽  
PETER J. STUCKEY
Keyword(s):  
Sufficient Conditions ◽  
Type Inference ◽  
Constraint Handling ◽  
Functional Dependencies ◽  
Type Classes ◽  
New Applications ◽  
First Time

AbstractFunctional dependencies are a popular and useful extension to Haskell style type classes. We give a reformulation of functional dependencies in terms of Constraint Handling Rules (CHRs). In previous work, CHRs have been employed for describing user-programmable type extensions in the context of Haskell style type classes. Here, we make use of CHRs to provide for the first time a concise result that under some sufficient conditions, functional dependencies allow for sound, complete and decidable type inference. The sufficient conditions imposed on functional dependencies can be very limiting. We show how to safely relax these conditions and suggest several sound extensions of functional dependencies. Our results allow for a better understanding of functional dependencies and open up the opportunity for new applications.

scholarly journals Principal type inference for GADTs

2016 ◽  
Vol 51 (1) ◽  
pp. 416-428 ◽  
Author(s):  
Sheng Chen ◽  
Martin Erwig
Keyword(s):  
Type Inference ◽  
Principal Type

scholarly journals Proof-relevant Horn Clauses for Dependent Type Inference and Term Synthesis

2018 ◽  
Vol 18 (3-4) ◽  
pp. 484-501 ◽  
Author(s):  
FRANTIŠEK FARKA ◽  
EKATERINA KOMENDANTSKYA ◽  
KEVIN HAMMOND
Keyword(s):  
Logic Program ◽  
Type Inference ◽  
Synthesis Problem ◽  
Dependent Types ◽  
Horn Clause ◽  
Data Types ◽  
First Order ◽  
Type Classes ◽  
The Given ◽  
Dependent Type

AbstractFirst-order resolution has been used for type inference for many years, including in Hindley-Milner type inference, type-classes, and constrained data types. Dependent types are a new trend in functional languages. In this paper, we show that proof-relevant first-order resolution can play an important role in automating type inference and term synthesis for dependently typed languages. We propose a calculus that translates type inference and term synthesis problems in a dependently typed language to a logic program and a goal in the proof-relevant first-order Horn clause logic. The computed answer substitution and proof term then provide a solution to the given type inference and term synthesis problem. We prove the decidability and soundness of our method.

Sign in / Sign up

Export Citation Format

Share Document