kure - a haskell hosted dsl for writing transformation systemsandygill/talks/20090715-kure.pdf ·...

KUREA Haskell Hosted DSL for Writing Transformation Systems

Andy Gill

The University of Kansas

July 15, 2009

Andy Gill (The University of Kansas) KURE July 15, 2009 1 / 27

Domain Specific Languages in Haskell

An Embedded Domain Specific Language is

simply a style of (Haskell) library.

You need to know Haskell!

User-code written in the DSL are centered

round a specific type (or types).

This talk: How to design a DSL using Haskell.


DSL Formula

Propose a small set of primitives;

Unify these combinators round a small number of type(s);

Postulate the monad that implements the primitives;

Wrap some structure round this monad, our principal type.

After this, the primitives in this shallow embedding are easy toimplement, using the monad, typically

Construction of our type, the atoms of our solution;

Combinators for our type, to compose solutions;

Execution of our type, to give a result.


Example Shallow Embedding

-- our principal type, Exprnewtype Expr = Expr (Maybe Int)

-- our way of constructing Expr’slit :: Int -> Exprlit n = Expr (Just n)

-- our way of composing Expr’splus :: Expr -> Expr -> Exprplus (Expr (Just v1)) (Expr (Just v2))

= Expr (Just (v1 + v2))plus _ _ = Expr Nothing

-- our way of running Expr’srunExpr :: Expr -> Maybe IntrunExpr (Expr v) = v


divide :: Expr -> Expr -> Exprdivide (Expr (Just v1)) (Expr (Just v2))

| v2 /= 0 = Expr (Just (v1 ‘div‘ v2))divide _ _ = Expr Nothing

*Main> runExpr (lit 1)Just 1*Main> runExpr (lit 1 ‘plus‘ lit 2)Just 3*Main> runExpr (lit 1 ‘divide‘ lit 2)Just 0*Main> runExpr (lit 1 ‘divide‘ lit 0)Nothing


What do we want our DSL to do?

Consider the first case rewriting rule from the Haskell 98 Report.

(a) case e of { alts } = (\v -> case v of { alts }) ewhere v is a new variable

Writing a rule that expresses this syntactical rewrite is straightforward.

rule_a :: ExpE -> Q ExpErule_a (CaseE e alts) = dov <- newName "v"return $ AppE (mkLamE [VarP v]

$ CaseE (VarE v) alts) erule_a _ = fail "rule_a not applicable"

KURE is a DSL that allows the structured promotion of locally acting rulesinto globally acting rules.


Basis of a Rewrite DSL

Combinator Purpose

id identity strategyfail always failing strategyS <+ S local backtrackingS ; S sequencingall(S) apply S to each immediate child<S> term apply S to term, giving a term result


Stratego Examples

Try a rewrite, and if it fails, do nothing.

try(s) = s <+ id

Repeatedly apply a rewrite, until it fails.

repeat(s) = try(s ; repeat(s))

Apply a rewrite in a topdown manner.

topdown(s) = s ; all(topdown(s))

New function for constant folding on an Add node.

EvalAdd : Add(Int(i),Int(j)) -> Int(<addS>(i,j))


What is our Principal Type?

T t1 t2

R t = T t t


Basic Operations in KURE

Combinator Type

id ∀t1. T t1 t1fail ∀t1, t2. T t1 t2S <+ S ∀t1, t2. T t1 t2 → T t1 t2 → T t1 t2S ; S ∀t1, t2, t3. T t1 t2 → T t2 t3 → T t1 t3


The KURE Monad

We list our requirements, then build our monad. We want the ability to

Represent failure

Represent identity

create new global binders

have a context

We use a monad transformer

M α = envread → m((α× envwrite × countwrite) + Fail)


Transformations and Monads

translate :: (t1 →M t2)→ T t1 t2

apply :: T t1 t2 → t1 →M t2

rewrite :: (t →M t)→ R t


Example: fib

data Exp = Val Int | Fib Exp | Add Exp Exp | Dec Exp

fibR :: R ExpfibR = rewrite $ \ e -> case e ofFib (Val 0) -> return $ Val 1Fib (Val 1) -> return $ Val 1Fib (Val n) -> return $ Add (Fib (Dec (Val n)))

(Fib (Dec (Dec (Val n))))_ -> fail "no match for fib"

eExpFibR :: R ExpeExpFibR =

repeatR (bottomupR (tryR (fibR <+ arithR)).+ failR "topdown done")


Where are we?

KURE allow us to build rewrite engines out of

small parts.

We can perform shallow and deep

transformations over a single type.

Most abstract syntax trees are constructed of

trees of multiple types.

Challenge (and main technical contribution of the paper)

Can we extend our typed rewrites to work over

multiple types?


What is the type of all?

all :: ∀t1. R t1 → R t1

OR

all :: ∀t1, t2. R t1 → R t2


Using a Universal Type

TP = ∀t1〈Term t1〉 ⇒ R t1

all :: TP→ TP

With a way to construct TP, we can combine rewrites on different types.

adhocTP :: ∀t1〈Term t1〉 TP→ R t1 → TPfailTP :: TP

all ((failTP ‘adhocTP‘ rr1) ‘adhocTP‘ rr2)


Our Typed Solution: Build Your Own Universal

Conceptually we want to pass in a tuple

all :: ∀t, t1, . . . , tn〈ti ∈ childrenOf t〉⇒ (R t1 ×R t2 × . . .×R tn)→ R t

But instead we work over a sum type

all :: ∀t, t1, . . . , tn〈ti ∈ childrenOf t〉⇒ R (t1 + t2 + . . .+ tn)→ R t

We do this using a type function, G

all :: ∀t〈G t〉 ⇒ R (G t)→ R t

where G is defined as

G ti = t1 + t2 + . . .+ tn where 0 < i ≤ n


The Term Class

class Term exp wheretype Generic *

-- | ’select’ selects into a ’Generic’ exp,-- to get the exp inside, or fails with Nothing.select :: Generic exp -> Maybe exp

-- | ’inject’ injects an exp into a ’Generic’ exp.inject :: exp -> Generic exp


Example instances of the Term Class

data OurGeneric = GStmt Stmt

| GExpr Expr

instance Term Stmt where

type Generic Stmt = OurGeneric

inject = GStmt

select (GStmt stmt) = Just stmt

select _ = Nothing

instance Term Expr where

...


The Walker Class, and other utils

class Term exp => Walker exp where

allR :: R (Generic exp) -> R exp

...

extractR :: (Term exp)

=> R (Generic exp) -> R exp

promoteR :: (Term exp)

=> R exp -> R (Generic exp)


Deep Traversals Attempt 1

-- INCORRECT TYPE, ATTEMPT 1

topdownR :: (Walker e)

=> R (Generic e)

-> R e

topdownR rr = extractR rr

>-> allR (promoteR (topdownR rr))

Type check failure!


Deep Traversals Attempt 2

-- INCORRECT TYPE, ATTEMPT 2

topdownR :: (Walker e)

=> R (Generic e)

-> R (Generic e)

topdownR rr = rr >-> allR (topdownR rr)

Problem: ‘Generic e’ itself is not an instance of G.


Universal Connector

tG

t1

77

Goooooooooooo

t2

??

G��

��

tn

gg

G OOOOOOOOOOOO

. . .

G..


Deep Traversals: Attempt 3

topdownR :: (Generic e ~ e, Walker e)=> R (Generic e)-> R (Generic e)

topdownR rr = rr >-> allR (topdownR rr)


Adding the OurGeneric instance

data OurGeneric = GStmt Stmt| GExpr Expr

instance Term Stmt wheretype Generic Stmt = OurGenericinject = GStmtselect (GStmt stmt) = Just stmtselect _ = Nothing

instance Term Expr where...

instance Term OurGeneric wheretype Generic OurGeneric = OurGenericinject e = eselect e = Just e


Review: DSL Formula

Propose a small set of primitives;

Unify these combinators round a small number of type(s);

Postulate the monad that implements the primitives;

Wrap some structure round this monad, our principal type.

After this, the primitives in this shallow embedding are easy toimplement, using the monad, typically

Construction of our type, the atoms of our solution;

Combinators for our type, to compose solutions;

Execution of our type, to give a result.


Considerations and Conclusions

DSLs are a way to structure code in a general purpose language.

Types Functions are a useful addition to Haskell.

Need to be a fan of the Haskell cool-aid.

What about debugging?


kure - a haskell hosted dsl for writing transformation systemsandygill/talks/20090715-kure.pdf ·...

Documents