Data types à la carte

Swierstra, Wouter

doi:10.1017/s0956796808006758

Cited by 231 publications

(167 citation statements)

References 7 publications

Supporting

Mentioning

167

Contrasting

Order By: Relevance

“…However, without a term representation based on pattern/shape functors (Swierstra, 2008), there is no way to express the type inhabited by the intermediate result after applying the algorithm to a node's sub-expressions before applying it to the node itself. We settle for wrapping and unwrapping the generated variable names with the Lit constructor.…”

Section: Benchmark: Tseitin Transformationmentioning

confidence: 99%

The Kansas University rewrite engine

Sculthorpe¹,

Frisby²,

Gill³

2014

J. Funct. Prog.

View full text Add to dashboard Cite

When writing transformation systems, a significant amount of engineering effort goes into setting up the infrastructure needed to direct individual transformations to specific targets in the data being transformed. Strategic programming languages provide general-purpose infrastructure for this task, which the author of a transformation system can use for any algebraic data structure.The Kansas University Rewrite Engine (KURE) is a typed strategic programming language, implemented as a Haskell-embedded domain-specific language. KURE is designed to support typed transformations over typed data, and the main challenge is how to make such transformations compatible with generic traversal strategies that should operate over any type.Strategic programming in a typed setting has much in common with datatype-generic programming. Compared to other approaches to datatype-generic programming, the distinguishing feature of KURE's solution is that the user can configure the behaviour of traversals based on the location of each datum in the tree, beyond their behaviour being determined by the type of each datum.This article describes KURE's approach to assigning types to generic traversals, and the implementation of that approach. We also compare KURE, its design choices, and their consequences, with other approaches to strategic and datatype-generic programming.

show abstract

Section: Benchmark: Tseitin Transformationmentioning

confidence: 99%

The Kansas University rewrite engine

Sculthorpe¹,

Frisby²,

Gill³

2014

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…In this section, we review the modular approach to datatypes and functions over them put forward by Swierstra [15], known as datatypesà la carte, and show how it can be used to obtain modular syntax and semantics for the language Expr previously described.…”

Section: Modular Syntax and Semanticsmentioning

confidence: 99%

“…Given a functor f, it is convenient to use a fold operator (sometimes called a catamorphism) [10] in order to define functions over Fix f [15]:…”

Section: Datatypesà La Cartementioning

confidence: 99%

“…And finally, Fix (f :+: g) and Fix (g :+: f) are isomorphic as languages, but require equivalent values to be tagged in different ways. The next two sections review how Swierstra resolves these problems [15], and shows how this can be used to obtain modular syntax and semantics for our language.…”

Section: Class (Monad M Functor F) => Eval F M Where Evalalg :: F (Mmentioning

confidence: 99%

“…-Modular syntax for a language can be defined using theà la carte approach to extensible data types developed by Swierstra [15];…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Towards Modular Compilers for Effects

Day

Hutton

2012

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Compilers are traditionally factorised into a number of separate phases, such as parsing, type checking, code generation, etc. However, there is another potential factorisation that has received comparatively little attention: the treatment of separate language features, such as mutable state, input/output, exceptions, concurrency and so forth. In this article we focus on the problem of modular compilation, in which the aim is to develop compilers for separate language features independently, which can then be combined as required. We summarise our progress to date, issues that have arisen, and further work.

show abstract

Modular Design of Domain-Specific Languages Using Splittings of Catamorphisms

Badouel

Djatcha

2018

Theoretical Aspects of Computing – ICTAC 2018

View full text Add to dashboard Cite

Language oriented programming is an approach to software composition based on domain specific languages (DSL) dedicated to specific aspects of an application domain. In order to combine such languages we embed them into a host language (namely Haskell, a strongly typed higher-order lazy functional language). A DSL is then given by an algebraic type, whose operators are the constructors of abstract syntax trees. Such a multi-sorted signature is associated to a polynomial functor. An algebra for this functor tells us how to interpret the programs. Using Bekić's Theorem we define a modular decomposition of algebras that leads to a class of parametric multi-sorted signatures, associated with regular functors, allowing for the modular design of DSLs.

show abstract

Data types à la carte

Abstract: This paper describes a technique for assembling both data types and functions from isolated individual components. We also explore how the same technology can be used to combine free monads and, as a result, structure Haskell's monolithic IO monad.

Cited by 231 publications

References 7 publications

The Kansas University rewrite engine

The Kansas University rewrite engine

Towards Modular Compilers for Effects

Modular Design of Domain-Specific Languages Using Splittings of Catamorphisms

Contact Info

Product

Resources

About