20 research outputs found
Translating Generalized Algebraic Data Types to System F
Generalized algebraic data types (GADTs) extend ordinary
algebraic data types by refining the types of constructors with syntactic
equality constraints. This is highly useful and allows for novel applications
such as strongly-typed evaluators, typed LR parsing etc. To translate
GADTs we need to enrich the System F style typed intermediate
languages of modern language implementations to capture these equality
constraints. We show that GADTs can be translated to a minor extension
of System F where type equality proofs are compiled into System
F typable proof terms. At run-time proof terms evaluate to the identity.
Hence, they can be safely erased before execution of the program. We
provide evidence that our approach scales to deal with extensions where
equality is not anymore syntactic. The benefit of our method is that type
checking of target programs remains as simple as type checking in System
F. Thus, we can offer a light-weight approach to integrate GADTs
and extensions of it into existing implementations
Supporting Separate Compilation in a Defunctionalizing Compiler
Defunctionalization is generally considered a whole-program
transformation and thus incompatible with separate compilation. In
this paper, we formalize a modular variant of defunctionalization which can support separate compilation. Our technique allows modules in a Haskell-like language to be separately defunctionalized and compiled, then linked together to generate an executable program. We provide a prototype implementation of our modular defunctionalization technique and we discuss the experiences of its application in a compiler from a large subset of Haskell to low-level C code, based on the intensional transformation
Defunctionalization with Dependent Types
The defunctionalization translation that eliminates higher-order functions
from programs forms a key part of many compilers. However, defunctionalization
for dependently-typed languages has not been formally studied. We present the
first formally-specified defunctionalization translation for a
dependently-typed language and establish key metatheoretical properties such as
soundness and type preservation. The translation is suitable for incorporation
into type-preserving compilers for dependently-typed language
Using rewriting to synthesize functional languages to digital circuits
A straightforward synthesis from functional languages to digital circuits transforms variables to wires. The types of these variables determine the bit-width of the wires. Assigning a bit-width to polymorphic and function-type variables within this direct synthesis scheme is impossible. Using a term rewrite system, polymorphic and function-type binders can be completely eliminated from a circuit description, given only minor and reasonable restrictions on the input. The presented term rewrite system is used in the compiler for CλaSH: a polymorphic, higher-order, functional hardware description language
A Type- and Control-Flow Analysis for System F: Technical Report
We present a monovariant flow analysis for System F (with recursion). The flow analysis yields both control-flow information, approximating the λ- and Λ-expressions that may be bound to variables, and type-flow information, approximating the type expressions that may instantiate type variables. Moreover, the two flows are mutually beneficial: the control flow determines which Λ-expressions may be applied to which type expressions (and, hence, which type expressions may instantiate which type variables), while the type flow filters the λ- and Λ-expressions that may be bound to variables (by rejecting expressions with static types that are incompatible with the static type of the variable under the type flow). As is typical for a monovariant control-flow analysis, control-flow information is expressed as an abstract environment mapping variables to sets of (syntactic) λ- and Λ-expressions that occur in the program under analysis. Similarly, type-flow information is expressed as an abstract environment mapping type variables to sets of (syntactic) types that occur in the program under analysis. Compatibility of static types (with free type variables) under a type flow is decided by interpreting the abstract environment as productions for a regular-tree grammar and querying if the languages generated by taking the types in question as starting terms have a non-empty intersection. This is a companion technical report, providing additional commentary and proof details, to a paper [11] appearing in Implementation and Application of Functional Languages: 24th International Symposium (IFL’12)
First-Class Functions for First-Order Database Engines
We describe Query Defunctionalization which enables off-the-shelf first-order
database engines to process queries over first-class functions. Support for
first-class functions is characterized by the ability to treat functions like
regular data items that can be constructed at query runtime, passed to or
returned from other (higher-order) functions, assigned to variables, and stored
in persistent data structures. Query defunctionalization is a non-invasive
approach that transforms such function-centric queries into the data-centric
operations implemented by common query processors. Experiments with XQuery and
PL/SQL database systems demonstrate that first-order database engines can
faithfully and efficiently support the expressive "functions as data" paradigm.Comment: Proceedings of the 14th International Symposium on Database
Programming Languages (DBPL 2013), August 30, 2013, Riva del Garda, Trento,
Ital
Refunctionalization at Work
We present the left inverse of Reynolds's defunctionalization and we show its relevance to programming and to programming languages. We present two methods to put a program that is almost in defunctionalized form into one that is actually in defunctionalized form, and we illustrate them with a recognizer for Dyck words and with Dijkstra's shunting-yard algorithm
Refunctionalization at Work
We present the left inverse of Reynolds's defunctionalization and we show its relevance to programming and to programming languages. We propose two methods to transform a program that is almost in defunctionalized form into one that is actually in defunctionalized form, and we illustrate them with a recognizer for Dyck words and with Dijkstra's shunting-yard algorithm
DĂ©fonctionnaliser pour prouver
National audienceCet article explore l'idée d'utiliser la défonctionnalisation comme une technique de preuve de programmes. La défonctionnalisation consiste à remplacer les valeurs fonctionnelles par une représentation du premier ordre. L'intérêt est alors de pouvoir utiliser ensuite un outil de preuve de programmes existant, sans lui ajouter de support pour l'ordre supérieur. Cet article illustre et discute cette approche à l'aide de plusieurs exemples et de l'outil de vérification déductive Why3