pres.mtask.tex

   1 \subsection{EDSLs}
   2 \begin{frame}
   3         \frametitle{Embedded Domain Specific Language}
   4         \framesubtitle{What are EDSLs}
   5         \begin{itemize}
   6                 \item DSL:\ language for a specific domain
   7                 \item E.g., PostScript, VimScript, HTML, \ldots
   8                 \pause{}
   9                 \item EDSL:\ Embedded DSL
  10                 \item Language in a language
  11                 \item Use the properties of the host
  12                 \item E.g., Ivory, \ldots\pause{} and iTasks
  13                 \pause{}
  14                 \item Different embedding techniques
  15         \end{itemize}
  16 \end{frame}
  17
  18 \begin{frame}[fragile]
  19         \frametitle{Deep embedding}
  20         \begin{columns}[t]
  21                 \column{.49\textwidth}
  22                 \onslide<1->{
  23                         \begin{block}{What is deep embedding}
  24                                 \begin{itemize}
  25                                         \item The EDSL as an ADT
  26                                         \item A view is a function transforming the ADT
  27                                 \end{itemize}
  28                         \end{block}
  29                 }
  30                 \onslide<3->{
  31                         \begin{block}{Properties}
  32                                 \begin{itemize}
  33                                         \item Easy to add views
  34                                         \item Hard to extend
  35                                         \item Not type safe
  36                                         \onslide<4->{
  37                                         \item GADT
  38                                         }
  39                                 \end{itemize}
  40                         \end{block}
  41                 }
  42                 \column{.49\textwidth}
  43                 \begin{onlyenv}<2->
  44                         \begin{lstlisting}[language=Clean]
  45 :: DSL = LitI  Int     | LitB  Bool
  46        | Var   String  | Plus  DSL DSL
  47        | Minus DSL DSL | And   DSL DSL
  48        | Eq    DSL
  49
  50 eval   :: DSL Env -> Env
  51 pprint :: DSL -> String
  52                         \end{lstlisting}
  53                 \end{onlyenv}
  54         \end{columns}
  55 \end{frame}
  56
  57 \begin{frame}[fragile]
  58         \frametitle{Shallow embedding}
  59         \begin{columns}[t]
  60                 \column{.49\textwidth}
  61                 \onslide<1->{
  62                         \begin{block}{What is shallow embedding}
  63                                 \begin{itemize}
  64                                         \item The EDSL as a function
  65                                         \item The view is embedded in the function
  66                                 \end{itemize}
  67                         \end{block}
  68                 }
  69
  70                 \onslide<2->{
  71                         \begin{block}{Properties}
  72                                 \begin{itemize}
  73                                         \item Difficult to add views
  74                                         \item Easy to extend
  75                                         \item Type safe
  76                                 \end{itemize}
  77                         \end{block}
  78                 }
  79                 \column{.49\textwidth}
  80                 \begin{onlyenv}<2->
  81                         \begin{lstlisting}[language=Clean]
  82 :: Env   = ...
  83 :: DSL a = DSL (Env -> a)
  84
  85 Lit :: a -> DSL a
  86 Lit x = \e -> x
  87
  88 Var :: String -> DSL Int
  89 Var i = \e -> retrEnv e i
  90
  91 Plus :: (DSL Int) (DSL Int) -> DSL Int
  92 Plus x y = \e -> x e + y e
  93                         \end{lstlisting}
  94                 \end{onlyenv}
  95         \end{columns}
  96 \end{frame}
  97
  98 \begin{frame}[fragile]
  99         \frametitle{Class based shallow embedding}
 100         \begin{columns}[t]
 101                 \column{.49\textwidth}
 102                 \onslide<1->{
 103                         \begin{block}{The best of both worlds}
 104                                 \begin{itemize}
 105                                         \item The EDSL is a collection of classes
 106                                         \item Views are types implementing a subset
 107                                 \end{itemize}
 108                         \end{block}
 109                 }
 110                 \onslide<3->{
 111                         \begin{block}{Properties}
 112                                 \begin{itemize}
 113                                         \item Extendable
 114                                         \item Type safe
 115                                         \item Easy to add views
 116                                         \item Phantom types for extra constraints
 117                                 \end{itemize}
 118                         \end{block}
 119                 }
 120                 \column{.49\textwidth}
 121                 \begin{onlyenv}<2->
 122                         \begin{lstlisting}[language=Clean]
 123 :: Env   = ...
 124 :: Evaluator a = Evaluator (Env -> a)
 125 :: PrettyPrinter a = PP String
 126
 127 class intArith v where
 128         lit   :: t -> v t | toString t
 129         add   :: (v t) (v t) -> (v t) | + t
 130         minus :: (v t) (v t) -> (v t) | - t
 131
 132 class boolArith v where ...
 133
 134 instance intArith Evaluator where
 135         lit x   = Evaluator \e->x
 136         add x y = Evaluator ...
 137         ...
 138
 139 instance intArith PrettyPrinter where
 140         lit x   = PP $ toString x
 141         add x y = PP $ x +++ "+" +++ y
 142         ...
 143                         \end{lstlisting}
 144                 \end{onlyenv}
 145         \end{columns}
 146 \end{frame}
 147
 148 \subsection{mTask}
 149 \begin{frame}
 150         \frametitle{mTask}
 151         \pause{}
 152         \begin{block}{What is mTask}
 153                 \begin{itemize}
 154                         \item Created by Pieter Koopman and Rinus Plasmeijer
 155                         \item EDSL for imperative programs
 156                         \item Arduino C++ generation, iTasks simulation
 157                 \end{itemize}
 158         \end{block}
 159
 160         \begin{block}{Considerations}
 161                 \begin{itemize}
 162                         \item Type safe
 163                         \item Embedded in Clean
 164                         \item Extendable
 165                 \end{itemize}
 166         \end{block}
 167 \end{frame}
 168
 169 \begin{frame}[fragile]
 170         \frametitle{Expressions}
 171         \begin{block}{mTask}
 172                 Of the form \CI{v t p}
 173         \end{block}
 174         \pause{}
 175         \begin{lstlisting}[language=Clean]
 176 class arith v where
 177   lit           :: t -> v t Expr
 178   (+.) infixl 6 :: (v t p) (v t q) -> v t Expr | +, zero t & isExpr p & isExpr q
 179   (-.) infixl 6 :: (v t p) (v t q) -> v t Expr | -, zero t & ...
 180   ...
 181 class boolExpr v where
 182   Not           :: (v Bool p) -> v Bool Expr            | ...
 183   (&.) infixr 3 :: (v Bool p) (v Bool q) -> v Bool Expr | ...
 184   ...
 185   (==.) infix 4 :: (v a p) (v a q) -> v Bool Expr       | ...
 186           \end{lstlisting}
 187 \end{frame}
 188
 189 \begin{frame}[fragile]
 190         \frametitle{Control flow}
 191         \begin{lstlisting}[language=Clean]
 192 class IF v where
 193   IF :: (v Bool p) (v t q) (v s r) -> v () Stmt | ...
 194   (?) infix 1 :: (v Bool p) (v t q) -> v () Stmt | ...
 195
 196 class seq v where
 197   (:.) infixr 0 :: (v t p) (v u q) -> v u Stmt | ...
 198         \end{lstlisting}
 199 \end{frame}
 200
 201 \begin{frame}[fragile]
 202         \frametitle{Assignment and Input/Output}
 203         \begin{lstlisting}[language=Clean]
 204 :: DigitalPin = D0 | D1 | D2 ...
 205 :: AnalogPin  = A0 | A1 | A2 ...
 206
 207 class dIO v where dIO :: DigitalPin -> v Bool Upd
 208 class aIO v where aIO :: AnalogPin -> v Int Upd
 209
 210 class analogRead v where
 211   analogRead :: AnalogPin -> v Int Expr
 212   analogWrite :: AnalogPin (v Int p) -> v Int Expr
 213
 214 class digitalRead v where
 215   digitalRead :: DigitalPin -> v Bin Expr
 216   digitalWrite :: DigitalPin (v Bool p) -> v Int Expr
 217   \end{lstlisting}
 218 \end{frame}
 219
 220 \begin{frame}[fragile]
 221         \frametitle{Shared Data Sources and Assignment}
 222         \begin{lstlisting}[language=Clean]
 223 :: In a b = In infix 0 a b
 224 :: Main a = {main :: a}
 225
 226 class sds v where
 227   sds :: ((v t Upd)->In t (Main (v c s))) -> (Main (v c s)) | ...
 228
 229 class assign v where
 230   (=.) infixr 2 :: (v t Upd) (v t p) -> v t Expr | ...
 231         \end{lstlisting}
 232 \end{frame}
 233
 234
 235 \begin{frame}[fragile]
 236         \frametitle{Tasks and Examples}
 237         \begin{lstlisting}[language=Clean]
 238 class mtask v a where
 239         task :: (((v delay r) a -> v MTask Expr) -> In (a->v u p) (Main (v t q)))
 240                 -> Main (v t q) | ...
 241         \end{lstlisting}
 242         \pause{}
 243         \begin{lstlisting}[language=Clean]
 244 blink = task \blink=(\x.
 245             IF x
 246                (ledOn LED1)
 247                (ledOff LED2) :.
 248             blink (lit 1000) (Not x))
 249         In {main=blink (lit 1000) True}
 250
 251 thermostat :: Main (View () Stmt)
 252 thermostat = {main = digitalWrite (dIO D0) (analogRead A0 >. lit 50)
 253
 254 thermostat2 :: Main (View () Stmt)
 255 thermostat = {main = (dIO D0) =. (analogRead A0 >. lit 50)
 256         \end{lstlisting}
 257 \end{frame}