Domain specific embedded compilers

Leijen, Daan; Meijer, Erik

doi:10.1145/331960.331977

Cited by 178 publications

(136 citation statements)

References 7 publications

Supporting

Mentioning

136

Contrasting

Order By: Relevance

“…The use of phantom type variables to type embedded languages was first introduced by Leijen and Meijer to type an embedding of SQL in Haskell [21]; it makes it possible to "tag" extra type information on data. In our context, we use it to add the information about the type of the join points matched by a pointcut: PC m a b means that a pointcut can match applications of functions of type a → m b.…”

Section: Typing Pointcutsmentioning

confidence: 99%

See 1 more Smart Citation

Effective Aspects: A Typed Monadic Embedding of Pointcuts and Advice

Figueroa

Tabareau

Tanter

2014

Transactions on Aspect-Oriented Software Development XI

View full text Add to dashboard Cite

Abstract. Aspect-oriented programming (AOP) aims to enhance modularity and reusability in software systems by offering an abstraction mechanism to deal with crosscutting concerns. However, in most general-purpose aspect languages aspects have almost unrestricted power, eventually conflicting with these goals. In this work we present Effective Aspects: a novel approach to embed the pointcut/advice model of AOP in a statically-typed functional programming language like Haskell. Our work extends EffectiveAdvice, by Oliveira, Schrijvers and Cook; which lacks quantification, and explores how to exploit the monadic setting in the full pointcut/advice model. Type soundness is guaranteed by exploiting the underlying type system, in particular phantom types and a new anti-unification type class. Aspects are first-class, can be deployed dynamically, and the pointcut language is extensible, therefore combining the flexibility of dynamically-typed aspect languages with the guarantees of a static type system. Monads enables us to directly reason about computational effects both in aspects and base programs using traditional monadic techniques. Using this we extend Aldrich's notion of Open Modules with effects, and also with protected pointcut interfaces to external advising. These restrictions are enforced statically using the type system. Also, we adapt the techniques of EffectiveAdvice to reason about and enforce control flow properties. Moreover, we show how to control effect interference using the parametricity-based approach of EffectiveAdvice. However this approach falls short when dealing with interference between multiple aspects. We propose a different approach using monad views, a recently developed technique for handling the monad stack. Finally, we exploit the properties of our monadic weaver to enable the modular construction of new semantics for aspect scoping and weaving. These semantics also benefit fully from the monadic reasoning mechanisms present in the language. This work brings type-based reasoning about effects for the first time in the pointcut/advice model, in a framework that is both expressive and extensible; thus allowing development of robust aspect-oriented systems as well as being a useful research tool for experimenting with new aspect semantics.

show abstract

Section: Typing Pointcutsmentioning

confidence: 99%

“…5). Type soundness is directly derived by relying on the existing type system of Haskell (type classes [47], phantom types [21], and some recent extensions of the Glasgow Haskell Compiler). Specifically, we define a novel type class for anti-unification [32,33], which is key to define safe aspects.…”

Section: Introductionmentioning

confidence: 99%

Effective Aspects: A Typed Monadic Embedding of Pointcuts and Advice

Figueroa

Tabareau

Tanter

2014

Transactions on Aspect-Oriented Software Development XI

View full text Add to dashboard Cite

show abstract

“…The benefits of embedding DSLs in Haskell are numerous and have been described, for example, by Hudak [5,6] as well as Leijen and Meijer [10]. Haskell allows for more readable embedded DSL programs with its infix function application, and monads provide a powerful abstraction of computations.…”

Section: Related Workmentioning

confidence: 99%

Declarative Scripting in Haskell

Bauer

Erwig

2010

Software Language Engineering

View full text Add to dashboard Cite

Abstract. We present a domain-specific language embedded within the Haskell programming language to build scripts in a declarative and typesafe manner. We can categorize script components into various orthogonal dimensions, or concerns, such as IO interaction, configuration, or error handling. In particular, we provide special support for two dimensions that are often neglected in scripting languages, namely creating deadlines for computations and tagging and tracing of computations. Arbitrary computations may be annotated with a textual tag explaining its purpose. Upon failure a detailed context for that error is automatically produced. The deadline combinator allows one to set a timeout on an operation. If it fails to complete within that amount of time, the computation is aborted. Moreover, this combinator works with the tag combinator so as to produce a contextual trace.

show abstract

“…For concreteness, let us review a simple example, due to Leijen and Meijer [8]. Consider a type of atoms, either booleans or integers, that can be easily represented as an algebraic datatype: datatype atom = I of int I B of bool There are a number of operations that we may perform on such atoms (see Figure 1 (a)).…”

Section: Introductionmentioning

confidence: 99%

“…This is the essence of the technique explored in this paper: using a free type variable to encode subtyping information and using an ML-like type system to enforce the subtyping. This "phantom types" technique, where user-defined restrictions are reflected in the constrained types of values and functions, underlies many interesting uses of type systems [14,12,2,13,6,8,5,11,1]. The main contributions of this paper are to exhibit a general encoding of subtyping hierarchies and to give one formalization of the use of the phantom types technique.…”

Section: Introductionmentioning

confidence: 99%

Phantom Types and Subtyping

Fluet

Pucella

2002

Foundations of Information Technology in the Era of Network and Mobile Computing

View full text Add to dashboard Cite

We investigate a technique from the literature, called the phantom types technique, that uses parametric polymorphism, type constraints, and unification of polymorphic types to model a subtyping hierarchy. Hindley-Milner type systems, such as the one found in ML, can be used to enforce the subtyping relation. We show that this technique can be used to encode any finite subtyping hierarchy (including hierarchies arising from multiple interface inheritance). We then formally demonstrate the suitability of the phantom types technique for capturing subtyping by exhibiting a type-preserving translation from a simple calculus with bounded polymorphism to a calculus embodying the type system of ML. IntroductionIt is well known that traditional type systems, such as the one found in Standard ML [10], with parametric polymorphism and type constructors can be used to capture program properties beyond those naturally associated with a Hindley-Milner type system [9]. For concreteness, let us review a simple example, due to Leijen and Meijer [8]. Consider a type of atoms, either booleans or integers, that can be easily represented as an algebraic datatype: datatype atom = I of int I B of bool There are a number of operations that we may perform on such atoms (see Figure 1 (a)). When the domain of an operation is restricted to only one kind of atom, as with conj and double, a run-time check must be made and an error or exception reported if the check fails.One aim of static type checking is to reduce the number of run-time checks by catching type errors at compile time. Of course, in the example above, the ML type system does not consider conj (mki 3, mkB true) to be ill-typed; evaluating this expression will simply raise a run-time exception.If we were working in a language with subtyping, we would like to consider integer atoms and boolean atoms as distinct subtypes of the general type of atoms and use these subtypes to refine the types of the operations. Then the type system would report a type error in the expression double (mkB false) at compile time. Fortunately, we can write the operations in a way that utilizes the ML type system to do just this. We

show abstract

Domain specific embedded compilers

Cited by 178 publications

References 7 publications

Effective Aspects: A Typed Monadic Embedding of Pointcuts and Advice

Effective Aspects: A Typed Monadic Embedding of Pointcuts and Advice

Declarative Scripting in Haskell

Phantom Types and Subtyping

Contact Info

Product

Resources

About