1 \documentclass[../thesis.tex
]{subfiles
}
4 \ifSubfilesClassLoaded{
8 \chapter{Deep embedding with class
}%
9 \label{chp:classy_deep_embedding
}
12 The two flavours of DSL embedding are shallow and deep embedding.
13 In functional languages, shallow embedding models the language constructs as functions in which the semantics are embedded.
14 Adding semantics is therefore cumbersome while adding constructs is a breeze.
15 Upgrading the functions to type classes lifts this limitation to a certain extent.
17 Deeply embedded languages represent their language constructs as data and the semantics are functions on it.
18 As a result, the language constructs are embedded in the semantics, hence adding new language constructs is laborious where adding semantics is trouble free.
20 This paper shows that by abstracting the semantics functions in deep embedding to type classes, it is possible to easily add language constructs as well.
21 So-called classy deep embedding results in DSLs that are extensible both in language constructs and in semantics while maintaining a concrete abstract syntax tree.
22 Additionally, little type-level trickery or complicated boilerplate code is required to achieve this.
25 \section{Introduction
}%
26 The two flavours of DSL embedding are deep and shallow embedding~
\cite{boulton_experience_1992
}.
27 In functional programming languages, shallow embedding models language constructs as functions in the host language.
28 As a result, adding new language constructs---extra functions---is easy.
29 However, the semantics of the language is embedded in these functions, making it troublesome to add semantics since it requires updating all existing language constructs.
31 On the other hand, deep embedding models language constructs as data in the host language.
32 The semantics of the language are represented by functions over the data.
33 Consequently, adding new semantics, i.e.\ novel functions, is straightforward.
34 It can be stated that the language constructs are embedded in the functions that form a semantics.
35 If one wants to add a language construct, all semantics functions must be revisited and revised to avoid ending up with partial functions.
37 This juxtaposition has been known for many years~
\cite{reynolds_user-defined_1978
} and discussed by many others~
\cite{krishnamurthi_synthesizing_1998
} but most famously dubbed the
\emph{expression problem
} by Wadler~
\cite{wadler_expression_1998
}:
40 The
\emph{expression problem
} is a new name for an old problem.
41 The goal is to define a data type by cases, where one can add new cases to the data type and new functions over the data type, without recompiling existing code, and while retaining static type safety (e.g., no casts).
44 In shallow embedding, abstracting the functions to type classes disentangles the language constructs from the semantics, allowing extension both ways.
45 This technique is dubbed tagless-final embedding~
\cite{carette_finally_2009
}, nonetheless it is no silver bullet.
46 Some semantics that require an intensional analysis of the syntax tree, such as transformation and optimisations, are difficult to implement in shallow embedding due to the lack of an explicit data structure representing the abstract syntax tree.
47 The semantics of the DSL have to be combined and must hold some kind of state or context, so that structural information is not lost~
\cite{kiselyov_typed_2012
}.
49 \subsection{Research contribution
}
50 This paper shows how to apply the technique observed in tagless-final embedding to deep embedding.
51 The presented basic technique, christened
\emph{classy deep embedding
}, does not require advanced type system extensions to be used.
52 However, it is suitable for type system extensions such as generalised algebraic data types.
53 While this paper is written as a literate
54 Haskell~
\cite{peyton_jones_haskell_2003
} program using some minor extensions provided by GHC~
\cite{ghc_team_ghc_2021
}, the idea is applicable to other languages as well
\footnotemark{}.
55 \footnotetext{Lubbers, M. (
2021): Literate Haskell/lhs2
\TeX{} source code of the paper ``Deep Embedding
56 with Class'': TFP
2022.\ DANS.\
\url{https://doi.org/
10.5281/zenodo
.5081386}.
}
58 \section{Deep embedding
}%
60 Pick a DSL, any DSL, pick the language of literal integers and addition.
61 In deep embedding, terms in the language are represented by data in the host language.
62 Hence, defining the constructs is as simple as creating the following algebraic data type
\footnote{All data types and functions are subscripted to indicate the evolution.
}.
64 \begin{lstHaskellLhstex
}
65 data Expr_0 = Lit_0 Int
67 \end{lstHaskellLhstex
}
69 Semantics are defined as functions on the
\haskelllhstexinline{Expr_0
} data type.
70 For example, a function transforming the term to an integer---an evaluator---is implemented as follows.
72 \begin{lstHaskellLhstex
}
73 eval_0 :: Expr_0 -> Int
75 eval_0 (Add_0 e1 e2) = eval_0 e1 + eval_0 e2
76 \end{lstHaskellLhstex
}
78 Adding semantics---e.g.\ a printer---just means adding another function while the existing functions remain untouched.
79 I.e.\ the key property of deep embedding.
80 The following function, transforming the
\haskelllhstexinline{Expr_0
} data type to a string, defines a simple printer for our language.
82 \begin{lstHaskellLhstex
}
83 print_0 :: Expr_0 -> String
84 print_0 (Lit_0 v) = show v
85 print_0 (Add_0 e1 e2) = "(" ++ print_0 e1 ++ "-" ++ print_0 e2 ++ ")"
86 \end{lstHaskellLhstex
}
88 While the language is concise and elegant, it is not very expressive.
89 Traditionally, extending the language is achieved by adding a case to the
\haskelllhstexinline{Expr_0
} data type.
90 So, adding subtraction to the language results in the following revised data type.
92 \begin{lstHaskellLhstex
}
93 data Expr_0 = Lit_0 Int
96 \end{lstHaskellLhstex
}
98 Extending the DSL with language constructs exposes the Achilles' heel of deep embedding.
99 Adding a case to the data type means that all semantics functions have become partial and need to be updated to be able to handle this new case.
100 This does not seem like an insurmountable problem, but it does pose a problem if either the functions or the data type itself are written by others or are contained in a closed library.
102 \section{Shallow embedding
}%
104 Conversely, let us see how this would be done in shallow embedding.
105 First, the data type is represented by functions in the host language with embedded semantics.
106 Therefore, the evaluators for literals and addition both become a function in the host language as follows.
108 \begin{lstHaskellLhstex
}
111 lit_s :: Int -> Sem_s
114 add_s :: Sem_s -> Sem_s -> Sem_s
115 add_s e1 e2 = e1 + e2
116 \end{lstHaskellLhstex
}
118 Adding constructions to the language is done by adding functions.
119 Hence, the following function adds subtraction to our language.
121 \begin{lstHaskellLhstex
}
122 sub_s :: Sem_s -> Sem_s -> Sem_s
123 sub_s e1 e2 = e1 - e2
124 \end{lstHaskellLhstex
}
126 Adding semantics on the other hand---e.g.\ a printer---is not that simple because the semantics are part of the functions representing the language constructs.
127 One way to add semantics is to change all functions to execute both semantics at the same time.
128 In our case this means changing the type of
\haskelllhstexinline{Sem_s
} to be
\haskellinline{(Int, String)
} so that all functions operate on a tuple containing the result of the evaluator and the printed representation at the same time.
%chktex 36
129 Alternatively, a single semantics can be defined that represents a fold over the language constructs~
\cite{gibbons_folding_2014
}, delaying the selection of semantics to the moment the fold is applied.
131 \subsection{Tagless-final embedding
}
132 Tagless-final embedding overcomes the limitations of standard shallow embedding.
133 To upgrade to this embedding technique, the language constructs are changed from functions to type classes.
134 For our language this results in the following type class definition.
136 \begin{lstHaskellLhstex
}
140 \end{lstHaskellLhstex
}
142 Semantics become data types
\footnotemark{} implementing these type classes, resulting in the following instance for the evaluator.
144 In this case
\haskelllhstexinline{newtype
}s are used instead of regular
\haskellinline{data
} declarations.
145 A
\haskelllhstexinline{newtype
} is a special data type with a single constructor containing a single value only to which it is isomorphic.
146 It allows the programmer to define separate class instances that the instances of the isomorphic type without any overhead.
147 During compilation the constructor is completely removed~
\cite[Sec.~
4.2.3]{peyton_jones_haskell_2003
}.
150 \begin{lstHaskellLhstex
}
151 newtype Eval_t = E_t Int
153 instance Expr_t Eval_t where
155 add_t (E_t e1) (E_t e2) = E_t (e1 + e2)
156 \end{lstHaskellLhstex
}
158 Adding constructs---e.g.\ subtraction---just results in an extra type class and corresponding instances.
160 \begin{lstHaskellLhstex
}
164 instance Sub_t Eval_t where
165 sub_t (E_t e1) (E_t e2) = E_t (e1 - e2)
166 \end{lstHaskellLhstex
}
168 Finally, adding semantics such as a printer over the language is achieved by providing a data type representing the semantics accompanied by instances for the language constructs.
170 \begin{lstHaskellLhstex
}
171 newtype Printer_t = P_t String
173 instance Expr_t Printer_t where
174 lit_t i = P_t (show i)
175 add_t (P_t e1) (P_t e2) = P_t ("(" ++ e1 ++ "+" ++ e2 ++ ")")
177 instance Sub_t Printer_t where
178 sub_t (P_t e1) (P_t e2) = P_t ("(" ++ e1 ++ "-" ++ e2 ++ ")")
179 \end{lstHaskellLhstex
}
181 \section{Lifting the backends
}%
183 Let us rethink the deeply embedded DSL design.
184 Remember that in shallow embedding, the semantics are embedded in the language construct functions.
185 Obtaining extensibility both in constructs and semantics was accomplished by abstracting the semantics functions to type classes, making the constructs overloaded in the semantics.
186 In deep embedding, the constructs are embedded in the semantics functions instead.
187 So, let us apply the same technique, i.e.\ make the semantics overloaded in the language constructs by abstracting the semantics functions to type classes.
188 The same effect may be achieved when using similar techniques such as explicit dictionary passing or ML style modules.
189 In our language this results in the following type class.
191 \begin{lstHaskellLhstex
}
195 data Expr_1 = Lit_1 Int
196 | Add_1 Expr_1 Expr_1
197 \end{lstHaskellLhstex
}
199 Implementing the semantics type class instances for the
\haskelllhstexinline{Expr_1
} data type is an elementary exercise.
200 By a copy-paste and some modifications, we come to the following implementation.
202 \begin{lstHaskellLhstex
}
203 instance Eval_1 Expr_1 where
205 eval_1 (Add_1 e1 e2) = eval_1 e1 + eval_1 e2
206 \end{lstHaskellLhstex
}
208 Subtraction can now be defined in a separate data type, leaving the original data type intact.
209 Instances for the additional semantics can now be implemented separately as instances of the type classes.
211 \begin{lstHaskellLhstex
}
212 data Sub_1 = Sub_1 Expr_1 Expr_1
214 instance Eval_1 Sub_1 where
215 eval_1 (Sub_1 e1 e2) = eval_1 e1 - eval_1 e2
216 \end{lstHaskellLhstex
}
218 \section{Existential data types
}%
220 The astute reader might have noticed that we have dissociated ourselves from the original data type.
221 It is only possible to create an expression with a subtraction on the top level.
222 The recursive knot is left untied and as a result,
\haskelllhstexinline{Sub_1
} can never be reached from an
\haskellinline{Expr_1
}.
224 Luckily, we can reconnect them by adding a special constructor to the
\haskelllhstexinline{Expr_1
} data type for housing extensions.
225 It contains an existentially quantified~
\cite{mitchell_abstract_1988
} type with type class constraints~
\cite{laufer_combining_1994,laufer_type_1996
} for all semantics type classes~
\cite[Chp.~
6.4.6]{ghc_team_ghc_2021
} to allow it to house not just subtraction but any future extension.
227 \begin{lstHaskellLhstex
}
228 data Expr_2 = Lit_2 Int
229 | Add_2 Expr_2 Expr_2
230 | forall x. Eval_2 x => Ext_2 x
231 \end{lstHaskellLhstex
}
233 The implementation of the extension case in the semantics type classes is in most cases just a matter of calling the function for the argument as can be seen in the semantics instances shown below.
235 \begin{lstHaskellLhstex
}
236 instance Eval_2 Expr_2 where
238 eval_2 (Add_2 e1 e2) = eval_2 e1 + eval_2 e2
239 eval_2 (Ext_2 x) = eval_2 x
240 \end{lstHaskellLhstex
}
242 Adding language construct extensions in different data types does mean that an extra
\haskelllhstexinline{Ext_2
} tag is introduced when using the extension.
243 This burden can be relieved by creating a smart constructor for it that automatically wraps the extension with the
\haskelllhstexinline{Ext_2
} constructor so that it is of the type of the main data type.
245 \begin{lstHaskellLhstex
}
246 sub_2 :: Expr_2 -> Expr_2 -> Expr_2
247 sub_2 e1 e2 = Ext_2 (Sub_2 e1 e2)
248 \end{lstHaskellLhstex
}
250 In our example this means that the programmer can write
\footnotemark{}:
252 Backticks are used to use functions or constructors in an infix fashion~
\cite[Sec.~
4.3.3]{peyton_jones_haskell_2003
}.
254 \begin{lstHaskellLhstex
}
256 e2 = Lit_2
42 `sub_2` Lit_2
1
257 \end{lstHaskellLhstex
}
258 instead of having to write
259 \begin{lstHaskellLhstex
}
261 e2p = Ext_2 (Lit_2
42 `Sub_2` Lit_2
1)
262 \end{lstHaskellLhstex
}
264 \subsection{Unbraiding the semantics from the data
}
265 This approach does reveal a minor problem.
266 Namely, that all semantics type classes are braided into our datatypes via the
\haskelllhstexinline{Ext_2
} constructor.
267 Say if we add the printer again, the
\haskelllhstexinline{Ext_2
} constructor has to be modified to contain the printer type class constraint as well
\footnote{Resulting in the following constructor:
\haskellinline{forall x.(Eval_2 x, Print_2 x) => Ext_2 x
}.
}.
%chktex 36
268 Thus, if we add semantics, the main data type's type class constraints in the
\haskelllhstexinline{Ext_2
} constructor need to be updated.
269 To avoid this, the type classes can be bundled in a type class alias or type class collection as follows.
271 \begin{lstHaskellLhstex
}
272 class (Eval_2 x, Print_2 x) => Semantics_2 x
274 data Expr_2 = Lit_2 Int
275 | Add_2 Expr_2 Expr_2
276 | forall x. Semantics_2 x => Ext_2 x
277 \end{lstHaskellLhstex
}
279 The class alias removes the need for the programmer to visit the main data type when adding additional semantics.
280 Unfortunately, the compiler does need to visit the main data type again.
281 Some may argue that adding semantics happens less frequently than adding language constructs but in reality it means that we have to concede that the language is not as easily extensible in semantics as in language constructs.
282 More exotic type system extensions such as constraint kinds~
\cite{bolingbroke_constraint_2011,yorgey_giving_2012
} can untangle the semantics from the data types by making the data types parametrised by the particular semantics.
283 However, by adding some boilerplate, even without this extension, the language constructs can be parametrised by the semantics by putting the semantics functions in a data type.
284 First the data types for the language constructs are parametrised by the type variable
\haskelllhstexinline{d
} as follows.
286 \begin{lstHaskellLhstex
}
287 data Expr_3 d = Lit_3 Int
288 | Add_3 (Expr_3 d) (Expr_3 d)
289 | forall x. Ext_3 (d x) x
290 \end{lstHaskellLhstex
}
292 \begin{lstHaskellLhstex
}
293 data Sub_3 d = Sub_3 (Expr_3 d) (Expr_3 d)
294 \end{lstHaskellLhstex
}
296 The
\haskelllhstexinline{d
} type variable is inhabited by an explicit dictionary for the semantics, i.e.\ a witness to the class instance.
297 Therefore, for all semantics type classes, a data type is made that contains the semantics function for the given semantics.
298 This means that for
\haskelllhstexinline{Eval_3
}, a dictionary with the function
\haskellinline{EvalDict_3
} is defined, a type class
\haskellinline{HasEval_3
} for retrieving the function from the dictionary and an instance for
\haskellinline{HasEval_3
} for
\haskellinline{EvalDict_3
}.
300 \begin{lstHaskellLhstex
}
301 newtype EvalDict_3 v = EvalDict_3 (v -> Int)
303 class HasEval_3 d where
304 getEval_3 :: d v -> v -> Int
306 instance HasEval_3 EvalDict_3 where
307 getEval_3 (EvalDict_3 e) = e
308 \end{lstHaskellLhstex
}
310 The instances for the type classes change as well according to the change in the datatype.
311 Given that there is a
\haskelllhstexinline{HasEval_3
} instance for the witness type
\haskellinline{d
}, we can provide an implementation of
\haskellinline{Eval_3
} for
\haskellinline{Expr_3 d
}.
313 \begin{lstHaskellLhstex
}
314 instance HasEval_3 d => Eval_3 (Expr_3 d) where
316 eval_3 (Add_3 e1 e2) = eval_3 e1 + eval_3 e2
317 eval_3 (Ext_3 d x) = getEval_3 d x
319 instance HasEval_3 d => Eval_3 (Sub_3 d) where
320 eval_3 (Sub_3 e1 e2) = eval_3 e1 - eval_3 e2
321 \end{lstHaskellLhstex
}
323 Because the
\haskelllhstexinline{Ext_3
} constructor from
\haskellinline{Expr_3
} now contains a value of type
\haskellinline{d
}, the smart constructor for
\haskellinline{Sub_3
} must somehow come up with this value.
324 To achieve this, a type class is introduced that allows the generation of such a dictionary.
326 \begin{lstHaskellLhstex
}
329 \end{lstHaskellLhstex
}
331 This type class has individual instances for all semantics dictionaries, linking the class instance to the witness value.
332 I.e.\ if there is a type class instance known, a witness value can be conjured using the
\haskelllhstexinline{gdict
} function.
334 \begin{lstHaskellLhstex
}
335 instance Eval_3 v => GDict (EvalDict_3 v) where
336 gdict = EvalDict_3 eval_3
337 \end{lstHaskellLhstex
}
339 With these instances, the semantics function can be retrieved from the
\haskelllhstexinline{Ext_3
} constructor and in the smart constructors they can be generated as follows:
341 \begin{lstHaskellLhstex
}
342 sub_3 :: GDict (d (Sub_3 d)) => Expr_3 d -> Expr_3 d -> Expr_3 d
343 sub_3 e1 e2 = Ext_3 gdict (Sub_3 e1 e2)
344 \end{lstHaskellLhstex
}
346 Finally, we reached the end goal, orthogonal extension of both language constructs as shown by adding subtraction to the language and in language semantics.
347 Adding the printer can now be done without touching the original code as follows.
348 First the printer type class, dictionaries and instances for
\haskelllhstexinline{GDict
} are defined.
350 \begin{lstHaskellLhstex
}
351 class Print_3 v where
352 print_3 :: v -> String
354 newtype PrintDict_3 v = PrintDict_3 (v -> String)
356 class HasPrint_3 d where
357 getPrint_3 :: d v -> v -> String
359 instance HasPrint_3 PrintDict_3 where
360 getPrint_3 (PrintDict_3 e) = e
362 instance Print_3 v => GDict (PrintDict_3 v) where
363 gdict = PrintDict_3 print_3
364 \end{lstHaskellLhstex
}
366 Then the instances for
\haskelllhstexinline{Print_3
} of all the language constructs can be defined.
368 \begin{lstHaskellLhstex
}
369 instance HasPrint_3 d => Print_3 (Expr_3 d) where
370 print_3 (Lit_3 v) = show v
371 print_3 (Add_3 e1 e2) = "(" ++ print_3 e1 ++ "+" ++ print_3 e2 ++ ")"
372 print_3 (Ext_3 d x) = getPrint_3 d x
373 instance HasPrint_3 d => Print_3 (Sub_3 d) where
374 print_3 (Sub_3 e1 e2) = "(" ++ print_3 e1 ++ "-" ++ print_3 e2 ++ ")"
375 \end{lstHaskellLhstex
}
377 \section{Transformation semantics
}%
379 Most semantics convert a term to some final representation and can be expressed just by functions on the cases.
380 However, the implementation of semantics such as transformation or optimisation may benefit from a so-called intentional analysis of the abstract syntax tree.
381 In shallow embedding, the implementation for these types of semantics is difficult because there is no tangible abstract syntax tree.
382 In off-the-shelf deep embedding this is effortless since the function can pattern match on the constructor or structures of constructors.
384 To demonstrate intensional analyses in classy deep embedding we write an optimizer that removes addition and subtraction by zero.
385 In classy deep embedding, adding new semantics means first adding a new type class housing the function including the machinery for the extension constructor.
387 \begin{lstHaskellLhstex
}
391 newtype OptDict_3 v = OptDict_3 (v -> v)
393 class HasOpt_3 d where
394 getOpt_3 :: d v -> v -> v
396 instance HasOpt_3 OptDict_3 where
397 getOpt_3 (OptDict_3 e) = e
399 instance Opt_3 v => GDict (OptDict_3 v) where
400 gdict = OptDict_3 opt_3
401 \end{lstHaskellLhstex
}
403 The implementation of the optimizer for the
\haskelllhstexinline{Expr_3
} data type is no complicated task.
404 The only interesting bit occurs in the
\haskelllhstexinline{Add_3
} constructor, where we pattern match on the optimised children to determine whether an addition with zero is performed.
405 If this is the case, the addition is removed.
407 \begin{lstHaskellLhstex
}
408 instance HasOpt_3 d => Opt_3 (Expr_3 d) where
409 opt_3 (Lit_3 v) = Lit_3 v
410 opt_3 (Add_3 e1 e2) = case (opt_3 e1, opt_3 e2) of
411 (Lit_3
0, e2p ) -> e2p
412 (e1p, Lit_3
0) -> e1p
413 (e1p, e2p ) -> Add_3 e1p e2p
414 opt_3 (Ext_3 d x) = Ext_3 d (getOpt_3 d x)
415 \end{lstHaskellLhstex
}
417 Replicating this for the
\haskelllhstexinline{Opt_3
} instance of
\haskellinline{Sub_3
} seems a clear-cut task at first glance.
419 \begin{lstHaskellLhstex
}
420 instance HasOpt_3 d => Opt_3 (Sub_3 d) where
421 opt_3 (Sub_3 e1 e2) = case (opt_3 e1, opt_3 e2) of
422 (e1p, Lit_3
0) -> e1p
423 (e1p, e2p ) -> Sub_3 e1p e2p
424 \end{lstHaskellLhstex
}
426 Unsurprisingly, this code is rejected by the compiler.
427 When a literal zero is matched as the right-hand side of a subtraction, the left-hand side of type
\haskelllhstexinline{Expr_3
} is returned.
428 However, the type signature of the function dictates that it should be of type
\haskelllhstexinline{Sub_3
}.
429 To overcome this problem we add a convolution constructor.
431 \subsection{Convolution
}%
433 Adding a loopback case or convolution constructor to
\haskelllhstexinline{Sub_3
} allows the removal of the
\haskellinline{Sub_3
} constructor while remaining the
\haskellinline{Sub_3
} type.
434 It should be noted that a loopback case is
\emph{only
} required if the transformation actually removes tags.
435 This changes the
\haskelllhstexinline{Sub_3
} data type as follows.
437 \begin{lstHaskellLhstex
}
438 data Sub_4 d = Sub_4 (Expr_4 d) (Expr_4 d)
439 | SubLoop_4 (Expr_4 d)
441 instance HasEval_4 d => Eval_4 (Sub_4 d) where
442 eval_4 (Sub_4 e1 e2) = eval_4 e1 - eval_4 e2
443 eval_4 (SubLoop_4 e1) = eval_4 e1
444 \end{lstHaskellLhstex
}
446 With this loopback case in the toolbox, the following
\haskelllhstexinline{Sub
} instance optimises away subtraction with zero literals.
448 \begin{lstHaskellLhstex
}
449 instance HasOpt_4 d => Opt_4 (Sub_4 d) where
450 opt_4 (Sub_4 e1 e2) = case (opt_4 e1, opt_4 e2) of
451 (e1p, Lit_4
0) -> SubLoop_4 e1p
452 (e1p, e2p ) -> Sub_4 e1p e2p
453 opt_4 (SubLoop_4 e) = SubLoop_4 (opt_4 e)
454 \end{lstHaskellLhstex
}
456 \subsection{Pattern matching
}%
458 Pattern matching within datatypes and from an extension to the main data type works out of the box.
459 Cross-extensional pattern matching on the other hand---matching on a particular extension---is something that requires a bit of extra care.
460 Take for example negation propagation and double negation elimination.
461 Pattern matching on values with an existential type is not possible without leveraging dynamic typing~
\cite{abadi_dynamic_1991,baars_typing_2002
}.
462 To enable dynamic typing support, the
\haskelllhstexinline{Typeable
} type class as provided by
\haskellinline{Data.Dynamic
}~
\cite{ghc_team_datadynamic_2021
} is added to the list of constraints in all places where we need to pattern match across extensions.
463 As a result, the
\haskelllhstexinline{Typeable
} type class constraints are added to the quantified type variable
\haskellinline{x
} of the
\haskellinline{Ext_4
} constructor and to
\haskellinline{d
}s in the smart constructors.
465 \begin{lstHaskellLhstex
}
466 data Expr_4 d = Lit_4 Int
467 | Add_4 (Expr_4 d) (Expr_4 d)
468 | forall x. Typeable x => Ext_4 (d x) x
469 \end{lstHaskellLhstex
}
471 First let us add negation to the language by defining a datatype representing it.
472 Negation elimination requires the removal of negation constructors, so a convolution constructor is defined as well.
474 \begin{lstHaskellLhstex
}
475 data Neg_4 d = Neg_4 (Expr_4 d)
476 | NegLoop_4 (Expr_4 d)
478 neg_4 :: (Typeable d, GDict (d (Neg_4 d))) => Expr_4 d -> Expr_4 d
479 neg_4 e = Ext_4 gdict (Neg_4 e)
480 \end{lstHaskellLhstex
}
482 The evaluation and printer instances for the
\haskelllhstexinline{Neg_4
} datatype are defined as follows.
484 \begin{lstHaskellLhstex
}
485 instance HasEval_4 d => Eval_4 (Neg_4 d) where
486 eval_4 (Neg_4 e) = negate (eval_4 e)
487 eval_4 (NegLoop_4 e) = eval_4 e
489 instance HasPrint_4 d => Print_4 (Neg_4 d) where
490 print_4 (Neg_4 e) = "(~" ++ print_4 e ++ ")"
491 print_4 (NegLoop_4 e) = print_4 e
492 \end{lstHaskellLhstex
}
494 The
\haskelllhstexinline{Opt_4
} instance contains the interesting bit.
495 If the sub expression of a negation is an addition, negation is propagated downwards.
496 If the sub expression is again a negation, something that can only be found out by a dynamic pattern match, it is replaced by a
\haskelllhstexinline{NegLoop_4
} constructor.
498 \begin{lstHaskellLhstex
}
499 instance (Typeable d, GDict (d (Neg_4 d)), HasOpt_4 d) => Opt_4 (Neg_4 d) where
500 opt_4 (Neg_4 (Add_4 e1 e2)) = NegLoop_4 (Add_4 (opt_4 (neg_4 e1)) (opt_4 (neg_4 e2)))
501 opt_4 (Neg_4 (Ext_4 d x)) = case fromDynamic (toDyn (getOpt_4 d x)) of
502 Just (Neg_4 e) -> NegLoop_4 e
503 _ -> Neg_4 (Ext_4 d (getOpt_4 d x))
504 opt_4 (Neg_4 e) = Neg_4 (opt_4 e)
505 opt_4 (NegLoop_4 e) = NegLoop_4 (opt_4 e)
506 \end{lstHaskellLhstex
}
508 Loopback cases do make cross-extensional pattern matching less modular in general.
509 For example,
\haskelllhstexinline{Ext_4 d (SubLoop_4 (Lit_4
0))
} is equivalent to
\haskellinline{Lit_4
0} in the optimisation semantics and would require an extra pattern match.
510 Fortunately, this problem can be mitigated---if required---by just introducing an additional optimisation semantics that removes loopback cases.
511 Luckily, one does not need to resort to these arguably blunt matters often.
512 Dependent language functionality often does not need to span extensions, i.e.\ it is possible to group them in the same data type.
514 \subsection{Chaining semantics
}
515 Now that the data types are parametrised by the semantics a final problem needs to be overcome.
516 The data type is parametrised by the semantics, thus, using multiple semantics, such as evaluation after optimising is not straightforwardly possible.
517 Luckily, a solution is readily at hand: introduce an ad-hoc combination semantics.
519 \begin{lstHaskellLhstex
}
520 data OptPrintDict_4 v = OPD_4 (OptDict_4 v) (PrintDict_4 v)
522 instance HasOpt_4 OptPrintDict_4 where
523 getOpt_4 (OPD_4 v _) = getOpt_4 v
524 instance HasPrint_4 OptPrintDict_4 where
525 getPrint_4 (OPD_4 _ v) = getPrint_4 v
527 instance (Opt_4 v, Print_4 v) => GDict (OptPrintDict_4 v) where
528 gdict = OPD_4 gdict gdict
529 \end{lstHaskellLhstex
}
531 And this allows us to write
\haskelllhstexinline{print_4 (opt_4 e1)
} resulting in
\verb|"((~
42)+(~
38))"| when
\haskellinline{e1
} represents $(
\sim(
42+
38))-
0$ and is thus defined as follows.
533 \begin{lstHaskellLhstex
}
534 e1 :: Expr_4 OptPrintDict_4
535 e1 = neg_4 (Lit_4
42 `Add_4` Lit_4
38) `sub_4` Lit_4
0
536 \end{lstHaskellLhstex
}
538 When using classy deep embedding to the fullest, the ability of the compiler to infer very general types expires.
539 As a consequence, defining reusable expressions that are overloaded in their semantics requires quite some type class constraints that cannot be inferred by the compiler (yet) if they use many extensions.
540 Solving this remains future work.
541 For example, the expression $
\sim(
42-
38)+
1$ has to be defined as:
543 \begin{lstHaskellLhstex
}
544 e3 :: (Typeable d, GDict (d (Neg_4 d)), GDict (d (Sub_4 d))) => Expr_4 d
545 e3 = neg_4 (Lit_4
42 `sub_4` Lit_4
38) `Add_4` Lit_4
1
546 \end{lstHaskellLhstex
}
548 \section{Generalised algebraic data types
}%
549 Generalised algebraic data types (GADTs) are enriched data types that allow the type instantiation of the constructor to be explicitly defined~
\cite{cheney_first-class_2003,hinze_fun_2003
}.
550 Leveraging GADTs, deeply embedded DSLs can be made statically type safe even when different value types are supported.
551 Even when GADTs are not supported natively in the language, they can be simulated using embedding-projection pairs or equivalence types~
\cite[Sec.~
2.2]{cheney_lightweight_2002
}.
552 Where some solutions to the expression problem do not easily generalise to GADTs (see
\cref{sec:cde:related
}), classy deep embedding does.
553 Generalising the data structure of our DSL is fairly straightforward and to spice things up a bit, we add an equality and boolean not language construct.
554 To make the existing DSL constructs more general, we relax the types of those constructors.
555 For example, operations on integers now work on all numerals instead.
556 Moreover, the
\haskelllhstexinline{Lit_g
} constructor can be used to lift values of any type to the DSL domain as long as they have a
\haskellinline{Show
} instance, required for the printer.
557 Since some optimisations on
\haskelllhstexinline{Not_g
} remove constructors and therefore use cross-extensional pattern matches,
\haskellinline{Typeable
} constraints are added to
\haskellinline{a
}.
558 Furthermore, because the optimisations for
\haskelllhstexinline{Add_g
} and
\haskellinline{Sub_g
} are now more general, they do not only work for
\haskellinline{Int
}s but for any type with a
\haskellinline{Num
} instance, the
\haskellinline{Eq
} constraint is added to these constructors as well.
559 Finally, not to repeat ourselves too much, we only show the parts that substantially changed.
560 The omitted definitions and implementation can be found in
\cref{sec:cde:appendix
}.
562 \begin{lstHaskellLhstex
}
563 data Expr_g d a where
564 Lit_g :: Show a => a -> Expr_g d a
565 Add_g :: (Eq a, Num a) => Expr_g d a -> Expr_g d a -> Expr_g d a
566 Ext_g :: Typeable x => d x -> x a -> Expr_g d a
568 Neg_g :: (Typeable a, Num a) => Expr_g d a -> Neg_g d a
569 NegLoop_g :: Expr_g d a -> Neg_g d a
571 Not_g :: Expr_g d Bool -> Not_g d Bool
572 NotLoop_g :: Expr_g d a -> Not_g d a
573 \end{lstHaskellLhstex
}
575 The smart constructors for the language extensions inherit the class constraints of their data types and include a
\haskelllhstexinline{Typeable
} constraint on the
\haskellinline{d
} type variable for it to be usable in the
\haskellinline{Ext_g
} constructor as can be seen in the smart constructor for
\haskellinline{Neg_g
}:
577 \begin{lstHaskellLhstex
}
578 neg_g :: (Typeable d, GDict (d (Neg_g d)), Typeable a, Num a) => Expr_g d a -> Expr_g d a
579 neg_g e = Ext_g gdict (Neg_g e)
581 not_g :: (Typeable d, GDict (d (Not_g d))) => Expr_g d Bool -> Expr_g d Bool
582 not_g e = Ext_g gdict (Not_g e)
583 \end{lstHaskellLhstex
}
585 Upgrading the semantics type classes to support GADTs is done by an easy textual search and replace.
586 All occurrences of
\haskelllhstexinline{v
} are now parametrised by type variable
\haskellinline{a
}:
588 \begin{lstHaskellLhstex
}
591 class Print_g v where
592 print_g :: v a -> String
595 \end{lstHaskellLhstex
}
597 Now that the shape of the type classes has changed, the dictionary data types and the type classes need to be adapted as well.
598 The introduced type variable
\haskelllhstexinline{a
} is not an argument to the type class, so it should not be an argument to the dictionary data type.
599 To represent this type class function, a rank-
2 polymorphic function is needed~
\cite[Chp.~
6.4.15]{ghc_team_ghc_2021
}\cite{odersky_putting_1996
}.
600 Concretely, for the evaluatior this results in the following definitions:
602 \begin{lstHaskellLhstex
}
603 newtype EvalDict_g v = EvalDict_g (forall a. v a -> a)
604 class HasEval_g d where
605 getEval_g :: d v -> v a -> a
606 instance HasEval_g EvalDict_g where
607 getEval_g (EvalDict_g e) = e
608 \end{lstHaskellLhstex
}
610 The
\haskelllhstexinline{GDict
} type class is general enough, so the instances can remain the same.
611 The
\haskelllhstexinline{Eval_g
} instance of
\haskellinline{GDict
} looks as follows:
613 \begin{lstHaskellLhstex
}
614 instance Eval_g v => GDict (EvalDict_g v) where
615 gdict = EvalDict_g eval_g
616 \end{lstHaskellLhstex
}
618 Finally, the implementations for the instances can be ported without complication show using the optimisation instance of
\haskelllhstexinline{Not_g
}:
620 \begin{lstHaskellLhstex
}
621 instance (Typeable d, GDict (d (Not_g d)), HasOpt_g d) => Opt_g (Not_g d) where
622 opt_g (Not_g (Ext_g d x)) = case fromDynamic (toDyn (getOpt_g d x)) :: Maybe (Not_g d Bool) of
623 Just (Not_g e) -> NotLoop_g e
624 _ -> Not_g (Ext_g d (getOpt_g d x))
625 opt_g (Not_g e) = Not_g (opt_g e)
626 opt_g (NotLoop_g e) = NotLoop_g (opt_g e)
627 \end{lstHaskellLhstex
}
629 \section{Conclusion
}%
631 Classy deep embedding is a novel organically grown embedding technique that alleviates deep embedding from the extensibility problem in most cases.
633 By abstracting the semantics functions to type classes they become overloaded in the language constructs.
634 Thus, making it possible to add new language constructs in a separate type.
635 These extensions are brought together in a special extension constructor residing in the main data type.
636 This extension case is overloaded by the language construct using a data type containing the class dictionary.
637 As a result, orthogonal extension is possible for language constructs and semantics using only little syntactic overhead or type annotations.
638 The basic technique only requires---well established through history and relatively standard---existential data types.
639 However, if needed, the technique generalises to GADTs as well, adding rank-
2 types to the list of type system requirements as well.
640 Finally, the abstract syntax tree remains observable which makes it suitable for intensional analyses, albeit using occasional dynamic typing for truly cross-extensional transformations.
642 Defining reusable expressions overloaded in semantics or using multiple semantics on a single expression requires some boilerplate still, getting around this remains future work.
644 \section{Related work
}%
645 \label{sec:cde:related
}
647 Embedded DSL techniques in functional languages have been a topic of research for many years, thus we do not claim a complete overview of related work.
649 Clearly, classy deep embedding bears most similarity to the
\emph{Datatypes \`a la Carte
}~
\cite{swierstra_data_2008
}.
650 In Swierstra's approach, semantics are lifted to type classes similarly to classy deep embedding.
651 Each language construct is their own datatype parametrised by a type parameter.
652 This parameter contains some type level representation of language constructs that are in use.
653 In classy deep embedding, extensions do not have to be enumerated at the type level but are captured in the extension case.
654 Because all the constructs are expressed in the type system, nifty type system tricks need to be employed to convince the compiler that everything is type safe and the class constraints can be solved.
655 Furthermore, it requires some boilerplate code such as functor instances for the data types.
656 In return, pattern matching is easier and does not require dynamic typing.
657 Classy deep embedding only strains the programmer with writing the extension case for the main data type and the occasional loopback constructor.
659 L\"oh and Hinze proposed a language extension that allows open data types and open functions, i.e.\ functions and data types that can be extended with more cases later on~
\cite{loh_open_2006
}.
660 They hinted at the possibility of using type classes for open functions but had serious concerns that pattern matching would be crippled because constructors are becoming types, thus ultimately becoming impossible to type.
661 In contrast, this paper shows that pattern matching is easily attainable---albeit using dynamic types---and that the terms can be typed without complicated type system extensions.
663 A technique similar to classy deep embedding was proposed by Najd and Peyton~Jones to tackle a slightly different problem, namely that of reusing a data type for multiple purposes in a slightly different form~
\cite{najd_trees_2017
}.
664 For example to decorate the abstract syntax tree of a compiler differently for each phase of the compiler.
665 They propose to add an extension descriptor as a type variable to a data type and a type family that can be used to decorate constructors with extra information and add additional constructors to the data type using an extension constructor.
666 Classy deep embedding works similarly but uses existentially quantified type variables to describe possible extensions instead of type variables and type families.
667 In classy deep embedding, the extensions do not need to be encoded in the type system and less boilerplate is required.
668 Furthermore, pattern matching on extensions becomes a bit more complicated but in return it allows for multiple extensions to be added orthogonally and avoids the necessity for type system extensions.
670 Tagless-final embedding is the shallowly embedded counterpart of classy deep embedding and was invented for the same purpose; overcoming the issues with standard shallow embedding~
\cite{carette_finally_2009
}.
671 Classy deep embedding was organically grown from observing the evolution of tagless-final embedding.
672 The main difference between tagless-final embedding and classy deep embedding---and in general between shallow and deep embedding---is that intensional analyses of the abstract syntax tree is more difficult because there is no tangible abstract syntax tree data structure.
673 In classy deep embedding, it is possible to define transformations even across extensions.
675 Hybrid approaches between deep and shallow embedding exist as well.
676 For example, Svenningson et al.\ show that by expressing the deeply embedded language in a shallowly embedded core language, extensions can be made orthogonally as well~
\cite{svenningsson_combining_2013
}.
677 This paper differs from those approaches in the sense that it does not require a core language in which all extensions need to be expressible.
679 \section*
{Acknowledgements
}
680 This research is partly funded by the Royal Netherlands Navy.
681 Furthermore, I would like to thank Pieter and Rinus for the fruitful discussions, Ralf for inspiring me to write a functional pearl, and the anonymous reviewers for their valuable and honest comments.
684 \begin{subappendices
}
685 \section{Data types and definitions
}%
686 \label{sec:cde:appendix
}
687 \begin{lstHaskellLhstex
}[caption=
{Data type definitions.
}]
689 Sub_g :: (Eq a, Num a) => Expr_g d a -> Expr_g d a -> Sub_g d a
690 SubLoop_g :: Expr_g d a -> Sub_g d a
693 Eq_g :: (Typeable a, Eq a) => Expr_g d a -> Expr_g d a -> Eq_g d Bool
694 EqLoop_g :: Expr_g d a -> Eq_g d a
695 \end{lstHaskellLhstex
}
697 \begin{lstHaskellLhstex
}[caption=
{Smart constructions.
}]
698 sub_g :: (Typeable d, GDict (d (Sub_g d)), Eq a, Num a) =>
699 Expr_g d a -> Expr_g d a -> Expr_g d a
700 sub_g e1 e2 = Ext_g gdict (Sub_g e1 e2)
702 eq_g :: (Typeable d, GDict (d (Eq_g d)), Eq a, Typeable a) =>
703 Expr_g d a -> Expr_g d a -> Expr_g d Bool
704 eq_g e1 e2 = Ext_g gdict (Eq_g e1 e2)
705 \end{lstHaskellLhstex
}
707 \begin{lstHaskellLhstex
}[caption=
{Semantics classes and data types.
}]
708 newtype PrintDict_g v = PrintDict_g (forall a.v a -> String)
710 class HasPrint_g d where
711 getPrint_g :: d v -> v a -> String
713 instance HasPrint_g PrintDict_g where
714 getPrint_g (PrintDict_g e) = e
716 newtype OptDict_g v = OptDict_g (forall a.v a -> v a)
718 class HasOpt_g d where
719 getOpt_g :: d v -> v a -> v a
721 instance HasOpt_g OptDict_g where
722 getOpt_g (OptDict_g e) = e
723 \end{lstHaskellLhstex
}
725 \begin{lstHaskellLhstex
}[caption=
{\texorpdfstring{\haskelllhstexinline{GDict
}}{GDict
} instances
}]
726 instance Print_g v => GDict (PrintDict_g v) where
727 gdict = PrintDict_g print_g
728 instance Opt_g v => GDict (OptDict_g v) where
729 gdict = OptDict_g opt_g
730 \end{lstHaskellLhstex
}
732 \begin{lstHaskellLhstex
}[caption=
{Evaluator instances
}]
733 instance HasEval_g d => Eval_g (Expr_g d) where
735 eval_g (Add_g e1 e2) = eval_g e1 + eval_g e2
736 eval_g (Ext_g d x) = getEval_g d x
738 instance HasEval_g d => Eval_g (Sub_g d) where
739 eval_g (Sub_g e1 e2) = eval_g e1 - eval_g e2
740 eval_g (SubLoop_g e) = eval_g e
742 instance HasEval_g d => Eval_g (Neg_g d) where
743 eval_g (Neg_g e) = negate (eval_g e)
744 eval_g (NegLoop_g e) = eval_g e
746 instance HasEval_g d => Eval_g (Eq_g d) where
747 eval_g (Eq_g e1 e2) = eval_g e1 == eval_g e2
748 eval_g (EqLoop_g e) = eval_g e
750 instance HasEval_g d => Eval_g (Not_g d) where
751 eval_g (Not_g e) = not (eval_g e)
752 eval_g (NotLoop_g e) = eval_g e
753 \end{lstHaskellLhstex
}
755 \begin{lstHaskellLhstex
}[caption=
{Printer instances
}]
756 instance HasPrint_g d => Print_g (Expr_g d) where
757 print_g (Lit_g v) = show v
758 print_g (Add_g e1 e2) = "(" ++ print_g e1 ++ "+" ++ print_g e2 ++ ")"
759 print_g (Ext_g d x) = getPrint_g d x
761 instance HasPrint_g d => Print_g (Sub_g d) where
762 print_g (Sub_g e1 e2) = "(" ++ print_g e1 ++ "-" ++ print_g e2 ++ ")"
763 print_g (SubLoop_g e) = print_g e
765 instance HasPrint_g d => Print_g (Neg_g d) where
766 print_g (Neg_g e) = "(negate " ++ print_g e ++ ")"
767 print_g (NegLoop_g e) = print_g e
769 instance HasPrint_g d => Print_g (Eq_g d) where
770 print_g (Eq_g e1 e2) = "(" ++ print_g e1 ++ "==" ++ print_g e2 ++ ")"
771 print_g (EqLoop_g e) = print_g e
773 instance HasPrint_g d => Print_g (Not_g d) where
774 print_g (Not_g e) = "(not " ++ print_g e ++ ")"
775 print_g (NotLoop_g e) = print_g e
776 \end{lstHaskellLhstex
}
778 \begin{lstHaskellLhstex
}[caption=
{Optimisation instances
}]
779 instance HasOpt_g d => Opt_g (Expr_g d) where
780 opt_g (Lit_g v) = Lit_g v
781 opt_g (Add_g e1 e2) = case (opt_g e1, opt_g e2) of
782 (Lit_g
0, e2p ) -> e2p
783 (e1p, Lit_g
0) -> e1p
784 (e1p, e2p ) -> Add_g e1p e2p
785 opt_g (Ext_g d x) = Ext_g d (getOpt_g d x)
787 instance HasOpt_g d => Opt_g (Sub_g d) where
788 opt_g (Sub_g e1 e2) = case (opt_g e1, opt_g e2) of
789 (e1p, Lit_g
0) -> SubLoop_g e1p
790 (e1p, e2p ) -> Sub_g e1p e2p
791 opt_g (SubLoop_g e) = SubLoop_g (opt_g e)
793 instance (Typeable d, GDict (d (Neg_g d)), HasOpt_g d) => Opt_g (Neg_g d) where
794 opt_g (Neg_g (Add_g e1 e2)) = NegLoop_g (Add_g (opt_g (neg_g e1)) (opt_g (neg_g e2)))
795 opt_g (Neg_g (Ext_g d x)) = case fromDynamic (toDyn (getOpt_g d x)) of
796 Just (Neg_g e) -> NegLoop_g e
797 _ -> Neg_g (Ext_g d (getOpt_g d x))
798 opt_g (Neg_g e) = Neg_g (opt_g e)
799 opt_g (NegLoop_g e) = NegLoop_g (opt_g e)
801 instance HasOpt_g d => Opt_g (Eq_g d) where
802 opt_g (Eq_g e1 e2) = Eq_g (opt_g e1) (opt_g e2)
803 opt_g (EqLoop_g e) = EqLoop_g (opt_g e)
804 \end{lstHaskellLhstex
}
808 \input{subfilepostamble
}