A Rewriting Semantics for Type Inference

Kuan, George; MacQueen, David; Findler, Robert Bruce

doi:10.1007/978-3-540-71316-6_29

Cited by 13 publications

(14 citation statements)

References 27 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The abstract machines that we use here are simplified versions of the abstract machines used in an earlier paper [4], where we were viewing type checking and inference as a term-rewriting system that incrementally transformed expressions into their types. The abstract machines described below express type inference as a process of nonstandard evaluation of expressions, yielding their types.…”

Section: An Abstract Machine For Classic Algorithm Wmentioning

confidence: 99%

Efficient type inference using ranked type variables

Kuan

MacQueen

2007

Proceedings of the 2007 Workshop on Workshop on ML

Self Cite

View full text Add to dashboard Cite

The Damas-Milner type inference algorithm (commonly known as algorithm W) is at the core of all ML type checkers. Although the algorithm is known to have poor worst-case behavior [8], in practice well-engineered type checkers will run in approximately linear time. To achieve this efficiency, implementations need to improve on algorithm W's method of scanning the complete type environment to determine whether a type variable can be generalized at a let binding. Following a suggestion of Damas, most ML type checkers use an alternative method based on ranking unification variables to track their position in the type environment.Here we formalize two such ranking systems, one based on lambda depth (used in the SML/NJ compiler), and the other based on let depth (used in OCaml, for instance). Each of these systems is formalized both with and without the value restriction, and they are proved correct relative to the classic algorithm W. Our formalizations of the various algorithms use simple abstract machines that are similar to those derived from small-step evaluation semantics.

show abstract

Section: An Abstract Machine For Classic Algorithm Wmentioning

confidence: 99%

Efficient type inference using ranked type variables

Kuan

MacQueen

2007

Proceedings of the 2007 Workshop on Workshop on ML

Self Cite

View full text Add to dashboard Cite

show abstract

“…extend (x , arg_type , gamma ))) in T_ARR ( arg_type , body_type ) end | check0 ( APP (e1 , e2 ), gamma ) = let val T_ARR (t1 , t2 ) = check0 (e1 , gamma ) val arg_type = check0 (e2 , gamma ) in if arg_type = t1 then t2 else raise ( TYPING_ERROR " type mismatch ") end ( * type_check : term -> typ * ) fun type_check t = check0 (t , TEnv . empty ) 2 In order to keep to the uniform approach for different semantics for type inference [17,25], we leave environments parametrized by the type parameter 'a, which is instantiated with typ in this case.…”

Section: Type Checking Proceduresmentioning

confidence: 99%

“…Reduction semantics for type checking, proposed initially by Kuan et al [17], is another operational view on type inference algorithms. Defined as a set of term-reduction rules, such a termrewriting system gives an operational view on the semantics of type checking, which is useful for debugging complex type systems, since the developer can trace each step of the type computation.…”

Section: Related Workmentioning

confidence: 99%

From type checking by recursive descent to type checking with an abstract machine

Sergey

Clarke

2011

Proceedings of the Eleventh Workshop on Language Descriptions, Tools and Applications

View full text Add to dashboard Cite

Modern type systems for programming languages usually incorporate additional information useful for program analysis, e.g., effects, control flow, non-interference, strictness etc. When designing a typing predicate for such systems, a form of logical derivation rules is normally taken. Despite the expressivity of this approach, the straightforward implementation of an appropriate type checker is usually inefficient in terms of stack consumption and further optimisations. This leads to a significant gap between an analysis and program implementing the analysis.In this paper we demonstrate an application of techniques investigated by Danvy et al. to derive an abstract machine for typing from the traditional recursive descent approach. All used techniques are off-the-shelf and no appropriate correspondence theorems between an initial type system and the derived abstract machine needs to be proven: they are instead corollaries of the correctness of inter-derivation and of the initial specification. Whereas a recursive descent is something straightforward to implement based on declarative typing rules, the derived abstract machine exposes behaviour similar to Landin's SECD machine and gives a solid basis for further optimizations using abstract interpretation.

show abstract

“…takes the time shown in columns 3-7 to be type checked using OCaml (version 3.10.1), Haskell (ghci version 6.8.2), SML/NJ (version 110.67), our K definition executed in Maude (version 2.3), the PLT-Redex definition of the W procedure [4], and an "off-the-shelf" implementation of W using OCaml [32].…”

Section: Fig 4 Unificationmentioning

confidence: 99%

A Rewriting Logic Approach to Type Inference

Ellison

Şerbănuţă

Roşu

2009

Recent Trends in Algebraic Development Techniques

View full text Add to dashboard Cite

Abstract. Meseguer and Ros , u proposed rewriting logic semantics (RLS) as a programing language definitional framework that unifies operational and algebraic denotational semantics. RLS has already been used to define a series of didactic and real languages, but its benefits in connection with defining and reasoning about type systems have not been fully investigated. This paper shows how the same RLS style employed for giving formal definitions of languages can be used to define type systems. The same termrewriting mechanism used to execute RLS language definitions can now be used to execute type systems, giving type checkers or type inferencers. The proposed approach is exemplified by defining the Hindley-Milner polymorphic type inferencer W as a rewrite logic theory and using this definition to obtain a type inferencer by executing it in a rewriting logic engine. The inferencer obtained this way compares favorably with other definitions or implementations of W . The performance of the executable definition is within an order of magnitude of that of highly optimized implementations of type inferencers, such as that of OCaml.

show abstract

A Rewriting Semantics for Type Inference

Cited by 13 publications

References 27 publications

Efficient type inference using ranked type variables

Efficient type inference using ranked type variables

From type checking by recursive descent to type checking with an abstract machine

A Rewriting Logic Approach to Type Inference

Contact Info

Product

Resources

About