X-Git-Url: https://git.martlubbers.net/?a=blobdiff_plain;f=methods.mtask.tex;h=38930c5bc762c6fd47182bcca9377003583a0563;hb=36d2564cca6ffab6506198f13545e5d02cf2b5cc;hp=67f4b4e264522312dc5ee6ecbf54c08638e8957e;hpb=d11a7941da4024ec8ff9ef6afaebb6eb9d2c6ed4;p=msc-thesis1617.git

diff --git a/methods.mtask.tex b/methods.mtask.tex
index 67f4b4e..38930c5 100644
--- a/methods.mtask.tex
+++ b/methods.mtask.tex
@@ -1,32 +1,32 @@
-The \gls{mTask}-\gls{EDSL} is the basis on which the system is built. The
-\gls{mTask}-\gls{EDSL} was created by Koopman et al.\ to support several views
-such as an \gls{iTasks} simulation and a \gls{C}-code generator. The \gls{EDSL}
-was designed to generate a ready to compile \gls{TOP}-like system for
-microcontrollers such as the \gls{Arduino}\cite{koopman_type-safe_nodate}%
+The \gls{mTask}-\gls{EDSL} is the language used for the proposed system. The
+\gls{mTask}-\gls{EDSL} was created by Koopman et al.\ and supports several
+views such as an \gls{iTasks} simulation and a \gls{C}-code generator. The
+\gls{EDSL} was designed to generate a ready-to-compile \gls{TOP}-like program
+for microcontrollers such as the \gls{Arduino}~\cite{koopman_type-safe_nodate}%
 \cite{plasmeijer_shallow_2016}.
 
 The \gls{mTask}-\gls{EDSL} is a shallowly embedded class based \gls{EDSL} and
 therefore it is very suitable to have a new backend that partly implements the
-given classes. The following sections show the details of the \gls{EDSL}
-that are used in this extension. The parts of the \gls{EDSL} that are not used
-will not be discussed and the details of those parts can be found in the cited
+classes given. The following sections show the details of the \gls{EDSL} that
+is used in this extension. The parts of the \gls{EDSL} that are not used will
+not be discussed and the details of those parts can be found in the cited
 literature.
 
-A view for the \gls{mTask}-\gls{EDSL} is a type with kind \CI{*->*->*}%
-\footnote{A type with two free type variables.} that implements some of the
-classes given. The types do not have to be present as fields in the higher
-kinded view and can, and will most often, solely be phantom types. A view is of
-the form \CI{v t r}. The first type variable will be the type of the view, the
-second type variable will be the type of the \gls{EDSL}-expression and the
-third type variable represents the role of the expression. Currently the role
-of the expressions form a hierarchy. The three roles and their hierarchy are
-shown in Listing~\ref{lst:exprhier}. This implies that everything is a
-statement, only a \CI{Upd} and a \CI{Expr} are expressions. The \CI{Upd}
+A view for the \gls{mTask}-\gls{EDSL} is a type with two free type
+variables\footnote{kind \CI{*->*->*}.} that implements some of the classes
+given. The types do not have to be present as fields in the higher kinded view
+and can, and will most often, be exclusively phantom types. Thus, views are of
+the form:\\\CI{:: v t r = ...}.  The first type variable will be the type of the
+view. The second type variable will be the type of the \gls{EDSL}-expression
+and the third type variable represents the role of the expression. Currently
+the role of the expressions form a hierarchy. The three roles and their
+hierarchy are shown in Listing~\ref{lst:exprhier}. This implies that everything
+is a statement, only a \CI{Upd} and a \CI{Expr} are expressions. The \CI{Upd}
 restriction describes updatable expressions such as \gls{GPIO} pins and
 \glspl{SDS}.
 
 \begin{lstlisting}[%
-	language=Clean,label={lst:exprhier},caption={Expression role hierarchy}]
+	label={lst:exprhier},caption={Expression role hierarchy}]
 :: Upd   = Upd
 :: Expr  = Expr
 :: Stmt  = Stmt
@@ -40,13 +40,13 @@ instance isExpr Expr
 Expressions in the \gls{mTask}-\gls{EDSL} are divided into two types, namely
 boolean expressions and arithmetic expressions. The class of arithmetic
 language constructs also contains the function \CI{lit} that lifts a
-host-language value in to the \gls{EDSL} domain. All standard arithmetic
+host-language value into the \gls{EDSL} domain. All standard arithmetic
 functions are included in the \gls{EDSL} but are omitted in the example for
 brevity. Moreover, the class restrictions are only shown in the first functions
-and omitted in subsequent funcitons. Both the boolean expression and arithmetic
-expression classes are shown in Listing~\ref{lst:arithbool}.
+and are omitted in subsequent functions. Both the boolean expression and
+arithmetic expression classes are shown in Listing~\ref{lst:arithbool}.
 
-\begin{lstlisting}[language=Clean,label={lst:arithbool},
+\begin{lstlisting}[label={lst:arithbool},
 	caption={Basic classes for expressions}]
 class arith v where
   lit           :: t -> v t Expr
@@ -62,24 +62,31 @@ class boolExpr v where
 
 \section{Control flow}
 Looping of \glspl{Task} happens because \glspl{Task} are executed after waiting
-a specified amount of time or when they are launched by another task or even
-themselves. Therefore there is no need for loop control flow functionality such
-as \emph{while} or \emph{for} constructions. The main control flow operators
-are the sequence operator and the \emph{if} statement. Both are shown in
-Listing~\ref{lst:control}. The first class of \emph{If} statements describes
+a specified amount of time or when they are launched by another \gls{Task} or
+even themselves. Therefore there is no need for loop control flow functionality
+such as \emph{while} or \emph{for} constructions. The main control flow
+operators are the sequence operator and the \emph{if} statement. Both are shown
+in Listing~\ref{lst:control}. The first class of \emph{If} statements describes
 the regular \emph{if} statement. The expressions given can have any role. The
-functional dependency on \CI{s} determines the return type of the
-statement. The listing includes examples of implementations that illustrate
-this dependency.
+functional dependency on \CI{s} determines the return type of the statement.
+The listing includes examples of implementations that illustrate this
+dependency. A special \emph{If} statement --- only used for statements --- is
+also added under the name \CI{IF}, of which the \CI{?} is a conditional
+statement to execute.
 
-The sequence operator is very straightforward and just ties
-the two expressions together in sequence.
+The sequence operator is straightforward and its only function is to tie
+two expressions together. The left expression is executed first, followed by
+the right expression.
 
 \begin{lstlisting}[%
-	language=Clean,label={lst:control},caption={Control flow operators}]
+	label={lst:control},caption={Control flow operators}]
 class If v q r ~s where
   If :: (v Bool p) (v t q) (v t r) -> v t s | ...
 
+class IF v where
+  IF :: (v Bool p) (v t q) (v s r) -> v () Stmt | ...
+  (?) infix 1 :: (v Bool p) (v t q) -> v () Stmt | ...
+
 instance If Code Stmt Stmt Stmt
 instance If Code e    Stmt Stmt
 instance If Code Stmt e    Stmt
@@ -92,12 +99,13 @@ class seq v where
 \section{Input/Output and class extensions}
 Values can be assigned to all expressions that have an \CI{Upd} role. Examples
 of such expressions are \glspl{SDS} and \gls{GPIO} pins. Moreover, class
-extensions can be created for specific peripherals such as builtin \glspl{LED}.
-The classes facilitating this are shown in Listing~\ref{lst:sdsio}. In this way
-the assignment is the same for every assignable entity.
+extensions can be created for specific peripherals such as built-in
+\glspl{LED}. The classes facilitating this are shown in
+Listing~\ref{lst:sdsio}. In this way the assignment is the same for every
+assignable entity.
 
 \begin{lstlisting}[%
-	language=Clean,label={lst:sdsio},caption={Input/Output classes}]
+	label={lst:sdsio},caption={Input/Output classes}]
 :: DigitalPin = D0 | D1 | D2 | D3 | D4 | D5 |D6 | D7 | D8 | D9 | D10 | D11 | D12 | D13
 :: AnalogPin  = A0 | A1 | A2 | A3 | A4 | A5
 :: UserLED = LED1 | LED2 | LED3
@@ -120,14 +128,16 @@ class assign v where
   (=.) infixr 2 :: (v t Upd) (v t p) -> v t Expr | ...
 \end{lstlisting}
 
-A way of storing data in \glspl{mTask} is using \glspl{SDS}. \glspl{SDS} serve
-as variables in the \gls{mTask} and maintain their value across executions.
-The classes associated with \glspl{SDS} are listed in
+One way of storing data in \gls{mTask}-\glspl{Task} is using \glspl{SDS}.
+\glspl{SDS} serve as variables in \gls{mTask} and maintain their value across
+executions.  \glspl{SDS} can be used by multiple \glspl{Task} and can be used
+to share data.  The classes associated with \glspl{SDS} are listed in
 Listing~\ref{lst:sdsclass}. The \CI{Main} type is introduced to box an
-\gls{mTask} and make it recognizable by the type system.
+\gls{mTask} and make it recognizable by the type system by separating programs
+and decorations such as \glspl{SDS}.
 
 \begin{lstlisting}[%
-	language=Clean,label={lst:sdsclass},caption={\glspl{SDS} in \gls{mTask}}]
+	label={lst:sdsclass},caption={\glspl{SDS} in \gls{mTask}}]
 :: In a b = In infix 0 a b
 :: Main a = {main :: a}
 
@@ -138,21 +148,22 @@ class sds v where
 \section{Semantics}
 The \gls{C}-backend of the \gls{mTask}-system has an engine that is generated
 alongside the code for the \glspl{Task}. This engine will execute the
-\glspl{mTask} according to certain rules and semantics.
-\glspl{mTask} do not behave like functions but more like
-\gls{iTasks}-\glspl{Task}. An \gls{mTask} is queued when either his timer runs
-out or when it is started by another \gls{mTask}. When an \gls{mTask} is
-queued it does not block the execution but it will return immediately while
-the actual \gls{Task} will be executed some time in the future.
+\gls{mTask}-\glspl{Task} according to certain rules and semantics.
+\gls{mTask}-\glspl{Task} do not behave like functions but more like
+\gls{iTasks}-\glspl{Task}. An \gls{mTask} is queued when either its timer runs
+out or when it is launched by another \gls{mTask}. When an \gls{mTask} is
+queued it does not block the execution and it will return immediately while the
+actual \gls{Task} will be executed anytime in the future.
 
 The \gls{iTasks}-backend simulates the \gls{C}-backend and thus uses the same
 semantics. This engine expressed in pseudocode is listed as
 Algorithm~\ref{lst:engine}. All the \glspl{Task} are inspected on their waiting
 time. When the waiting time has not passed; the delta is subtracted and the
-task gets pushed to the end of the queue. When the waiting has surpassed they are
-executed. When an \gls{mTask} wants to queue another \gls{mTask} it can just
-append it to the queue.
+\gls{Task} gets pushed to the end of the queue. When the waiting has surpassed
+they are executed. When an \gls{mTask} opts to queue another \gls{mTask} it
+can just append it to the queue.
 
+~\\
 \begin{algorithm}[H]
 	\KwData{\textbf{queue} queue, \textbf{time} $t, t_p$}
 
@@ -173,19 +184,20 @@ append it to the queue.
 		}
 	}
 	\caption{Engine pseudocode for the \gls{C}- and
-		\gls{iTasks}-backend}\label{lst:engine}
+		\gls{iTasks}-view}\label{lst:engine}
 \end{algorithm}
+~\\
 
-To achieve this in the \gls{EDSL} a \gls{Task} clas are added that work in a
+To achieve this in the \gls{EDSL} a \gls{Task} class is added that work in a
 similar fashion as the \texttt{sds} class. This class is listed in
 Listing~\ref{lst:taskclass}. \glspl{Task} can have an argument and always have
 to specify a delay or waiting time. The type signature of the \CI{mtask} is
 complex and therefore an example is given. The aforementioned Listing
-shows a simple specification containing one task that increments a value
+shows a simple specification containing one \gls{Task} that increments a value
 indefinitely every one seconds.
 
-\begin{lstlisting}[language=Clean,label={lst:taskclass},%
-	caption={The classes for defining tasks}]
+\begin{lstlisting}[label={lst:taskclass},%
+	caption={The classes for defining \glspl{Task}}]
 class mtask v a where
   task :: (((v delay r) a->v MTask Expr)->In (a->v u p) (Main (v t q))) -> Main (v t q) | ...
 
@@ -193,17 +205,20 @@ count = task \count = (\n.count (lit 1000) (n +. One)) In {main = count (lit 100
 \end{lstlisting}
 
 \section{Example mTask}
-Some example \glspl{mTask} using almost all of the functionality are shown in
-Listing~\ref{lst:exmtask}. The \glspl{mTask} shown in the example do not belong
-to a particular view and therefore are of the type \CI{View t r}. The
-\CI{blink} \gls{mTask} show the classic \gls{Arduino} \emph{Hello World!}
-application that blinks a certain \gls{LED} every second. The \CI{thermostat}
-expression will enable a digital pin powering a cooling fan when the analog pin
-representing a temperature sensor is too high. \CI{thermostat`} shows the same
-expression but now using the assignment style \gls{GPIO} technique.
+Some example \gls{mTask}-\glspl{Task} using almost all of their functionality
+are shown in Listing~\ref{lst:exmtask}. The \gls{mTask}-\glspl{Task} shown in
+the example do not belong to a particular view and therefore are of the type
+\CI{View t r}.  The \CI{blink} \gls{mTask} show the classic \gls{Arduino}
+blinking led application that blinks a certain \gls{LED} every second. The
+\CI{thermostat} expression will enable a digital pin powering a cooling fan
+when the analog pin representing a temperature sensor is too high.
+\CI{thermostat`} shows the same expression but now using the assignment style
+\gls{GPIO} technique. The \CI{thermostat} example also shows that it is not
+necessary to run everything as a \CI{task}. The main program code can also just
+consist of the contents of the root \CI{main} itself.
 
 \begin{lstlisting}[%
-	language=Clean,label={lst:exmtask},caption={Some example \glspl{mTask}}]
+	label={lst:exmtask},caption={Some example \gls{mTask}-\glspl{Task}}]
 blink = task \blink=(\x.
 		IF (x ==. lit True) (ledOn led) (ledOff led) :.
 		blink (lit 1000) (Not x)
@@ -211,7 +226,7 @@ blink = task \blink=(\x.
 
 thermostat :: Main (View () Stmt)
 thermostat = {main =
-  IF (analogRead A0 >. 50)
+  IF (analogRead A0 >. lit 50)
 	( digitalWrite D0 (lit True)  )
     ( digitalWrite D0 (lit False) )
   }
@@ -219,5 +234,5 @@ thermostat = {main =
 thermostat` :: Main (View () Stmt)
 thermostat` = let 
   a0 = aIO A0
-  d0 = dIO D0 in {main = IF (a0 >. 50) (d0 =. lit True) (d0 =. lit False) }
+  d0 = dIO D0 in {main = IF (a0 >. lit 50) (d0 =. lit True) (d0 =. lit False) }
 \end{lstlisting}