Pattern matching rewrites with internal DSL? - scala

Question

My question is about DSL design. It is related to internal vs. external DSLs, but is more specific than that.
Background info: I have gone through DSL in Action and other tutorials. The difference between internal and external is clear to me. I also have experience developing external DSLs in Haskell.
Let's take a very simple example. Here below a (simplified) relational algebra exression:
SELECT conditions (
CROSS (A,B)
)
Algebra expressions (ADT in Haskell) can be easily rewritten. For example, this can be trivially rewritten into:
JOIN conditions (A,B)
In the DSLs I have developed, I have always taken this approach: write a parser which creates algebraic expressions like the one above. Then, with a language that allows pattern matching like Haskell, apply a number of rewrites and eventually translate into a target language.
Here comes the question.
For a new DSL I would like to develop, I'd rather opt for an internal DSL. Mainly because I want to take advantage of the host language capabilities (probably Scala in this case). The debate of whether this is the right choice is not the point here. Let's assume its a good choice.
What I miss is: if I go for an internal DSL, then there is no parsing into an ADT. Where is my loved pattern matching rewrite going to fit into this? Do I have to give up on it? Are there best practices to get the best of the two worlds? Or am I not seeing things correctly here?

Answer 1

I'll demonstrate this using an internal expression language for arithmetic in Haskell. We'll implement double-negation elimination.
Internal DSL "embeddings" are either deep or shallow. Shallow embeddings mean that you rely upon sharing operations from the host language to make the domain language run. In our example, this almost annihilates the very DSL-ness of our problem. I'll show it anyway.
newtype Shallow = Shallow { runShallow :: Int }
underShallow1 :: (Int -> Int) -> (Shallow -> Shallow)
underShallow1 f (Shallow a) = Shallow (f a)
underShallow2 :: (Int -> Int -> Int) -> (Shallow -> Shallow -> Shallow)
underShallow2 f (Shallow a) (Shallow b) = Shallow (f a b)
-- DSL definition
instance Num Shallow where
fromInteger n = Shallow (fromInteger n) -- embed constants
(+) = underShallow2 (+) -- lifting host impl into the DSL
(*) = underShallow2 (*)
(-) = underShallow2 (-)
negate = underShallow negate
abs = underShallow abs
signum = underShallow signum
So now we write and execute our Shallow DSL using the overloaded Num methods and runShallow :: Shallow -> Int
>>> fromShallow (2 + 2 :: Shallow)
4
Notably, since everything in this Shallow embedding is represented internally with almost no structure besides the result since all of the work has been dropped down to the host language where our domain language can't "see" it.
A deep embedding clearly separates the representation and the interpretation of a DSL. Typically, a good way to represent it is an ADT which has branches and arities which match a minimal, basis API. We'll just reflect the whole Num class
data Deep
= FromInteger Integer
| Plus Deep Deep
| Mult Deep Deep
| Subt Deep Deep
| Negate Deep
| Abs Deep
| Signum Deep
deriving ( Eq, Show )
Notably, this representation will admit equality (note that this is the smallest equality possible since it ignores "values" and "equivalences") and showing, which is nice. We tie it into the same internal API by instantiating Num
instance Num Deep where
fromInteger = FromInteger
(+) = Plus
(*) = Mult
(-) = Subt
negate = Negate
abs = Abs
signum = Signum
but now we have to create an interpreter which ties the deep embedding into values represented in the host language. Here an advantage of Deep embeddings arises in that we can trivially introduce multiple interpreters. For instance, "showing" can be considered an interpreter from Deep to String
interpretString :: Deep -> String
interpretString = show
We can count the number of embedded constants as an interpreter
countConsts :: Deep -> Int
countConsts x = case x of
FromInteger _ = 1
Plus x y = countConsts x + countConsts y
Mult x y = countConsts x + countConsts y
Subt x y = countConsts x + countConsts y
Negate x = countConsts x
Abs x = countConsts x
Signum x = countConsts x
And finally we can interpret the thing into not just an Int but any other thing which follows the Num API
interp :: Num a => Deep -> a
interp x = case x of
FromInteger n = fromInteger n
Plus x y = interp x + interp y
Mult x y = interp x * interp y
Subt x y = interp x - interp y
Negate x = negate (interp x)
Abs x = abs (interp x)
Signum x = signum (interp x)
So, finally, we can create a deep embedding and execute it in several ways
>>> let x = 3 + 4 * 5 in (interpString x, countConsts x, interp x)
(Plus (FromInteger 3) (Mult (FromInteger 4) (FromInteger 5)), 3, 23)
And, here's the finale, we can use our Deep ADT to implement optimizations
opt :: Deep -> Deep
opt x = case x of
(Negate (Negate x)) -> opt x
FromInteger n = FromInteger n
Plus x y = Plus (opt x) (opt y)
Mult x y = Mult (opt x) (opt y)
Subt x y = Sub (opt x) (opt y)
Negate x = Negate (opt x)
Abs x = Abs (opt x)
Signum x = Signum (opt x)