First commit

Author: josefs

219px-Ericsson_logo.png

@@ -0,0 +1,21 @@
+Combining Deep and Shallow embeddings for EDSLs
+===============================================
+
+Embedded domain specific languages are typically categorized as either
+deep or shallow embeddings. In deep embeddings the object language is
+implemented by constructing a syntax tree in the host language. This
+syntax tree can then be manipulated and evaluated in many different
+ways. Shallow embeddings give a direct interpretation of the object
+language in the host language which can can give rise to succinct and
+fast implementations.
+
+In this tutorial we will advocate a combined approach, using a deeply
+embedded core of the object language and model additional language
+features using shallow embeddings. This combination gives considerable
+flexibility in experimenting with language features. It also enables a
+powerful form of partial evaluation for the object language
+
+This tutorial will include several examples of the synergies that come
+out of this combined approach. Some of these examples will be taken
+from our experience with implementing Feldspar, a language for digital
+signal processing designed together with industrial partners.

Chalmers_logo.png

@@ -0,0 +1,8 @@
+tutorialSlides.html: tutorialSlides.md
+	pandoc tutorialSlides.md -t slidy -s -o tutorialSlides.html
+
+tutorial.pdf: tutorial.tex
+	pdflatex tutorial.tex
+
+tutorial.tex: tutorial.md Makefile
+	pandoc tutorial.md -t latex -o tutorial.tex -s --bibliography tutorial.bib

DslTutorial.txt

@@ -0,0 +1,55 @@
+{-# LANGUAGE GADTs #-}
+module Tutorial where
+
+data FunC a where
+  LitI  :: Int  -> FunC Int
+  LitB  :: Bool -> FunC Bool
+  Arr   :: FunC Int -> (FunC Int -> a) -> FunC (Array Int a)
+  While :: (s -> FunC Bool) -> (s -> s) -> s -> FunC s
+  If    :: FunC Bool -> FunC a -> FunC a -> FunC a
+  Pair  :: FunC a -> FunC b -> FunC (a,b)
+  Prim  :: String -> a -> FunC a
+
+class Syntactic a where
+  type Internal a
+  toFunC   :: a -> FunC (Internal a)
+  fromFunC :: FunC (Internal a) -> a
+
+-- Shallow Embeddings
+
+-- Complex Numbers
+
+data Complex = Complex (FunC Float) (FunC Float)
+
+instance Syntactic Complex where
+  type Internal (Complex) = (Float,Float)
+  fromFunC (Complex i r) = Pair (i,r)
+  toFunC p = Complex (fst p) (snd p)
+
+-- Vectors
+
+data Vector a where
+  Indexed :: FunC Int -> (FunC Int -> a) -> Vector a
+
+instance Syntactic (Vector a) where
+  type Internal (Vector a) = Array Int a
+  fromFunC (Vector l ix) = Arr l ix
+  toFunC arr = Vector (length arr) (\ix -> arr ! ix)
+
+-- Interesting variation: statically sized vectors
+
+data SVector a where
+  SVector :: Int -> (FunC Int -> a) -> SVector a
+
+-- Streams
+
+data Stream a where
+  Stream :: (s -> (a,s)) -> s -> Stream a
+
+-- Finite stream (sequential vectors)
+
+data FStream a where
+  FStream :: FunC Int -> (s -> (a,s)) -> s -> FStream a
+
+data SFStream a where
+  SFStream :: Int -> (s -> (a,s)) -> s -> SFStream a

Makefile

@@ -0,0 +1,117 @@
+% Combining Deep and Shallow Embeddings
+% Josef Svenningsson
+%
+
+
+# Introduction
+
+The advantages of embedding domain specific languages are well known.
+It helps the language implementor(s) focus on language design by
+leveraging the parser and (when applicable) the type checker of the
+host language.
+
+When embedding a language there are several techniques to choose from
+which are typically categorized as *shallow* and *deep*
+embeddings. These techniques have their individual merits and are
+often considered separate.
+
+In this tutorial we will show that much can be gained from combining
+deep and shallow embeddings. More concretely we will show the benefits
+of starting with a deep embedding and adding language constructs which
+are implemented using shallow embeddings on top of the deep embedding.
+
+## Terminology
+
+Before getting to the meat of this tutorial we will establish some
+terminology.
+
+We will use *object language* to refer to the DSL which is being
+embedded.  In this tutorial we will see two examples of object
+languages. The term *host language* will be used to refer to the
+language which the object language is embedded in. We will use Haskell
+as our host language throughout this tutorial.
+
+# Contrast Deep and Shallow Embeddings
+
+Before delving into the subject of combining deep and shallow
+embeddings let be precise about what those terms mean and the way that
+we will use them in tutorial.
+
+Running example contrasting deep and shallow
+
+Simple arithmetic language
+
+~~~
+(+) :: SInt -> SInt -> SInt
+(*) :: SInt -> SInt -> SInt
+5 :: SInt
+~~~
+
+# Example Embedding
+
+# Deep Embedding
+
+# Shallow Embedding
+
+# Main example
+
+# Functional C -- Deep Embedding
+
+# Various Shallow Embeddings
+
+# Vectors
+
+# Sequential Vectors
+
+# Streams
+
+# Pairs
+
+# Complex Numbers
+
+A good example of where we experimented with a feature using the shallow
+embedding but then included it in the deep embedding.
+
+
+A good example of where we experimented with a feature using the shallow
+embedding but then included it in the deep embedding.
+
+
+# Fixed Point Numbers
+
+# Type Class for seamless mixing
+
+A type class which summarizes all the language features -- both shallowly
+and deeply embedded
+
+# Partial Evaluation
+
+The host language is effectively the meta language of the object language.
+
+# Other hybrid approaches
+
+There are other approaches to combining deep and shallow embeddings, not to be
+confused with the one presented in this tutorial.
+
+In the implementation of Kansas Lava they store shallow values in the
+syntax tree for easy access [@Farmer:10:WhatsTheMatter].
+
+In the Feldspar project we do something similar but 
+
+## Finally Tagless
+
+The Finally Tagless approach is an alternative method to embed
+languages. It has a lot of the same advantages as the approach we have
+presented in this tutorial and can in some cases even be considered
+superiour.
+
+
+Why haven't I said anything about the Finally Tagless approach. The
+Finally Tagless approach solves some of the same problems that I've
+talked about in this tutorial.
+
+* Problems with weird types involving type variables and type constraints
+* Not nice for end users who are not themselves functional programmers
+* It doesn't mix well with observable sharing
+
+# References

Tutorial.hs

@@ -0,0 +1,133 @@
+% Combining Deep and Shallow Embeddings: A Tutorial
+% Josef Svenningsson
+%
+
+# Combining Deep and Shallow Embeddings
+
+# Background
+
+The ideas I'm going to present in this tutorial have been used
+extensively in the development of Feldspar.
+
+Feldspar is a domain specific language 
+
+Feldspar is a collaboration between:
+
+----                               ----
+Chalmers University of Technology  ![Chalmers logo]
+ELTE University                    ![ELTE logo]
+Ericsson                           ![Ericsson logo]
+----                               ----
+
+[Chalmers logo]: Chalmers_logo.png
+[ELTE logo]: cimer.png
+[Ericsson logo]: 219px-Ericsson_logo.png
+
+# Contrast Deep and Shallow Embeddings
+
+Running example contrasting deep and shallow
+
+Simple arithmetic language
+
+~~~
+(+) :: SInt -> SInt -> SInt
+(*) :: SInt -> SInt -> SInt
+5 :: SInt
+~~~
+
+# Example Embedding
+
+# Deep Embedding
+
+# Shallow Embedding
+
+# Hybrid approaches
+
+In Kansas Lava they use a hybrid approach where the deep embedding contains
+a shallow embedding.
+
+~~~
+data Signal a = Signal (Stream a) (D a)
+
+data Stream a = a :~ Stream a
+
+type D a = AST
+~~~
+
+# Conclusion: Deep and Shallow embeddings
+
+Deep and Shallow embeddings are two important ways to embed a target language
+in a host language
+
+These are certainly not the only ways to embed a language, but they will be
+the focus in this tutorial.
+
+# Main example
+
+# Functional C -- Deep Embedding
+
+Our example language for demonstrating our main point is a small
+functional flavored C.
+
+It is inspired by the core language used in Feldspar, which has served us well
+for writing embedded software.
+
+
+# Various Shallow Embeddings
+
+# Vectors
+
+# Sequential Vectors
+
+# Streams
+
+# Pairs
+
+# Complex Numbers
+
+A good example of where we experimented with a feature using the shallow
+embedding but then included it in the deep embedding.
+
+
+A good example of where we experimented with a feature using the shallow
+embedding but then included it in the deep embedding.
+
+
+# Fixed Point Numbers
+
+# Type Class for seamless mixing
+
+A type class which summarizes all the language features -- both shallowly
+and deeply embedded
+
+# Partial Evaluation
+
+The host language is effectively the meta language of the object language.
+
+Haskell values are static.
+
+DSL values are dynamic.
+
+Should I show the Binding Time module?
+
+# Analysis and optimization of shallow embeddings
+
+We can optimize vectors even further if we know something about their shape.
+
+Show example with `(++)`.
+
+
+[Final:ish slide]
+# Finally Tagless
+
+Why haven't I said anything about the Finally Tagless approach. The
+Finally Tagless approach solves some of the same problems that I've
+talked about in this tutorial.
+
+* Problems with weird types involving type variables and type constraints
+* Not nice for end users who are not themselves functional programmers
+* It doesn't mix well with observable sharing
+
+# Thanks
+
+Thanks!