TinkerType: a language for playing with formal systems

TinkerType is a pragmatic framework for compact and modular description of formal systems (type systems, operational semantics, logics, etc.). A family of related systems is broken down into a set of clauses – individual inference rules – and a set of features controlling the inclusion of clauses in particular systems. Simple static checks are used to help maintain consistency of the generated systems. We present TinkerType and its implementation and describe its application to two substantial repositories of typed lambda-calculi. The first repository covers a broad range of typing features, including subtyping, polymorphism, type operators and kinding, computational effects, and dependent types. It describes both declarative and algorithmic aspects of the systems, and can be used with our tool, the TinkerType Assembler, to generate calculi either in the form of typeset collections of inference rules or as executable ML typecheckers. The second repository addresses a smaller collection of systems, and provides modularized proofs of basic safety properties.

[1]  Carl A. Gunter Semantics of programming languages: structures and techniques , 1993, Choice Reviews Online.

[2]  Harold Ossher,et al.  Multi-dimensional Separation of Concerns in Hyperspace Multi-dimensional Separation of Concerns in Hyperspace , 1999 .

[3]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[4]  J. LandinP. Correspondence between ALGOL 60 and Church's Lambda-notation , 1965 .

[5]  Christian Prehofer,et al.  Feature-Oriented Programming: A Fresh Look at Objects , 1997, ECOOP.

[6]  Luca Viganò,et al.  A Modular Presentation of Modal Logics in a Logical Framework , 1998 .

[7]  Gordon D. Plotkin,et al.  Abstract syntax and variable binding , 1999, Proceedings. 14th Symposium on Logic in Computer Science (Cat. No. PR00158).

[8]  Martín Abadi,et al.  A Theory of Objects , 1996, Monographs in Computer Science.

[9]  Gregor Kiczales,et al.  Aspect-oriented programming , 2001, ESEC/FSE-9.

[10]  Paul Hudak,et al.  Monad transformers and modular interpreters , 1995, POPL '95.

[11]  Eugenio Moggi,et al.  Computational lambda-calculus and monads , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[12]  P. J. Landin,et al.  The next 700 programming languages , 1966, CACM.

[13]  Stanley M. Sutton,et al.  N degrees of separation: multi-dimensional separation of concerns , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[14]  Frank Pfenning,et al.  Higher-order abstract syntax , 1988, PLDI '88.

[15]  John C. Mitchell,et al.  Foundations for programming languages , 1996, Foundation of computing series.

[16]  Benjamin C. Pierce,et al.  Bounded quantification is undecidable , 1992, POPL '92.

[17]  Martin Odersky,et al.  Type Inference with Constrained Types , 1999, Theory Pract. Object Syst..

[18]  Peter D. Mosses Action Semantics , 1986, ADT.

[19]  Samuel N. Kamin,et al.  Modular compilers based on monad transformers , 1998, Proceedings of the 1998 International Conference on Computer Languages (Cat. No.98CB36225).

[20]  David A. Espinosa Semantic Lego , 1995 .

[21]  Bart Jacobs,et al.  Categorical Logic and Type Theory , 2001, Studies in logic and the foundations of mathematics.

[22]  Paul Hudak,et al.  Modular Denotational Semantics for Compiler Construction , 1996, ESOP.

[23]  Daniele Turi,et al.  Abstract Syntax and Variable Binding (Extended Abstract) , 2003 .

[24]  Benjamin C. Pierce,et al.  Recursive subtyping revealed: (functional pearl) , 2000, ICFP '00.

[25]  F. Honsell,et al.  A Framework for De ning LogicsRobert Harper , 1987 .

[26]  Verzekeren Naar Sparen,et al.  Cambridge , 1969, Humphrey Burton: In My Own Time.

[27]  Guy L. Steele,et al.  Building interpreters by composing monads , 1994, POPL '94.

[28]  R. Lathe Phd by thesis , 1988, Nature.

[29]  Harold Ossher,et al.  Subject-oriented programming: a critique of pure objects , 1993, OOPSLA '93.

[30]  Joseph A. Goguen,et al.  Introducing Institutions , 1983, Logic of Programs.

[31]  Furio Honsell,et al.  A framework for defining logics , 1993, JACM.

[32]  Benjamin C. Pierce,et al.  Recursive subtyping revealed , 2000, Journal of Functional Programming.