X-Git-Url: https://git.martlubbers.net/?a=blobdiff_plain;f=methods.dsl.tex;h=9b8bf48cb77fe5fbe594b5367fa22a02a3b1aedb;hb=c1a2d537de7ff3d730d26658daa822b2f03ea110;hp=2d0aab221a0e43320914efeba1d040b3365c5b3b;hpb=b0fc85be57e369c5a04adaba4d6920a59d3d36e2;p=msc-thesis1617.git

diff --git a/methods.dsl.tex b/methods.dsl.tex
index 2d0aab2..9b8bf48 100644
--- a/methods.dsl.tex
+++ b/methods.dsl.tex
@@ -8,53 +8,53 @@ techniques are briefly explained.
 A deep \gls{EDSL} means that the language is represented as an \gls{ADT}. Views
 are functions that transform something to the datatype or the other way around.
 As an example we have the simple arithmetic \gls{EDSL} shown in
-Listing~\ref{lst:exdeep}. Deep embedding has the advantage that it is very
-simple to build and the views are easy to make and add. However, there are also
-a few downsides.
+Listing~\ref{lst:exdeep}.
 
 \begin{lstlisting}[language=Clean,label={lst:exdeep},%
 	caption={A minimal deep \gls{EDSL}}]
 :: DSL
-	= LitI Int
-	| LitB Bool
-	| Var String
-	| Plus DSL DSL
+	= LitI  Int
+	| LitB  Bool
+	| Var   String
+	| Plus  DSL DSL
 	| Minus DSL DSL
-	| And DSL DSL
-	| Eq DSL
+	| And   DSL DSL
+	| Eq    DSL
 \end{lstlisting}
-
-The expressions created with this language are not type-safe. In the given
-language it is possible an expression such as \CI{Plus (LitI 4) (LitB True)}
-which to add a boolean to an integer. Evermore so, extending the \gls{ADT} is
-easy and convenient but extending the views accordingly is tedious and has to
-be done individually for all views.
+Deep embedding has the advantage that it is very simple to build and the views
+are easy to make and add. However, there are also a few downsides.  The
+expressions created with this language are not type-safe. In the given language
+it is possible an expression such as \CI{Plus (LitI 4) (LitB True)} which to
+add a boolean to an integer. Evermore so, extending the \gls{ADT} is easy and
+convenient but extending the views accordingly is tedious and has to be done
+individually for all views.
 
 The first downside of the type of \gls{EDSL} can be overcome by using
-\glspl{GADT}. Listing~\ref{lst:exdeepgadt} shows the same language, but
-type-safe with a \gls{GADT}\footnote{\glspl{GADT} are not supported
-in the current version of \gls{Clean}. However, they can be simulated using
-bimaps}. Unfortunately the lack of extendability stays a problem. If a language
-construct is added no compile time guarantee is given that all views support
-it.
+\glspl{GADT}\cite{cheney_first-class_2003}. Listing~\ref{lst:exdeepgadt} shows
+the same language, but type-safe with a \gls{GADT}. \glspl{GADT} are not
+supported in the current version of \gls{Clean} and therefore the syntax is
+artificial. However, it has been shown that \glspl{GADT} can be simulated using
+bimaps or projection pairs\cite{cheney_lightweight_2002}. Unfortunately the
+lack of extendability stays a problem. If a language construct is added no
+compile time guarantee is given that all views support it.
 
 \begin{lstlisting}[language=Clean,label={lst:exdeepgadt},%
 	caption={A minimal deep \gls{EDSL} using \glspl{GADT}}]
 :: DSL a
-	= LitI Int                     -> DSL Int
-	| LitB Bool                    -> DSL Bool
-	| Var String                   -> DSL Int
-	| Plus   (DSL Int) (DSL Int)   -> DSL Int
-	| Minus  (DSL Int) (DSL Int)   -> DSL Int
-	| And    (DSL Bool) (DSL Bool) -> DSL Bool
-	| E.e: Eq (DSL e) (DSL e)       -> DSL Bool   &  == e
+	=     LitI  Int                   -> DSL Int
+	|     LitB  Bool                  -> DSL Bool
+	| E.e: Var   String                -> DSL e
+	|     Plus  (DSL Int) (DSL Int)   -> DSL Int
+	|     Minus (DSL Int) (DSL Int)   -> DSL Int
+	|     And   (DSL Bool) (DSL Bool) -> DSL Bool
+	| E.e: Eq (DSL e) (DSL e)          -> DSL Bool &  == e
 \end{lstlisting}
 
 \subsection{Shallow embedding}
 In a shallowly \gls{EDSL} all language constructs are expressed as functions in
 the host language. An evaluator view for our example language then looks
 something like the code shown in Listing~\ref{lst:exshallow}. Note that much of
-the internals of the language can be hidden away using monads.
+the internals of the language can be hidden using monads.
 
 \begin{lstlisting}[language=Clean,label={lst:exshallow},%
 	caption={A minimal shallow \gls{EDSL}}]
@@ -114,13 +114,13 @@ choose to implement only parts of the collection of classes.
 :: PrettyPrinter a = PP String
 
 class intArith where
-	lit :: t -> v t | toString t
-	add :: (v t) (v t) -> (v t) | + t
+	lit   :: t -> v t             | toString t
+	add   :: (v t) (v t) -> (v t) | + t
 	minus :: (v t) (v t) -> (v t) | - t
 
 class boolArith where
 	and :: (v Bool) (v Bool) -> (v Bool)
-	eq :: (v t) (v t) -> (v Bool) | == t
+	eq  :: (v t)    (v t)    -> (v Bool) | == t
 
 instance intArith Evaluator where
 	lit x = \e->x