X-Git-Url: https://git.martlubbers.net/?a=blobdiff_plain;f=methods.top.tex;h=3acfb17cf1a5d81fe203409053f15b78415bc72c;hb=7ca87066ed1f3a962d993a9ac32ab761cfdc05a9;hp=982ac24a6fc1db4cc34db7b0897e84084d29067f;hpb=8c6f463e3da3f3a2469b44f17705d633c988fee6;p=msc-thesis1617.git diff --git a/methods.top.tex b/methods.top.tex index 982ac24..3acfb17 100644 --- a/methods.top.tex +++ b/methods.top.tex @@ -1,10 +1,9 @@ -\section{\acrlong{TOP}} -\subsection{\gls{iTasks}} -\gls{TOP} is a recent programming paradigm implemented as +\section{iTasks} +\gls{TOP} is a modern recent programming paradigm implemented as \gls{iTasks}\cite{achten_introduction_2015} in the pure lazy functional language \gls{Clean}\cite{brus_cleanlanguage_1987}. \gls{iTasks} is a -\gls{EDSL} to model workflow tasks in the broadest sense. A \CI{Task} is just -a function that, given some state, returns the observable \CI{TaskValue}. The +\gls{EDSL} to model workflow tasks in the broadest sense. A \gls{Task} is just +a function that --- given some state --- returns the observable \CI{TaskValue}. The \CI{TaskValue} of a \CI{Task} can have different states. Not all state transitions are possible as shown in Figure~\ref{fig:taskvalue}. Once a value is stable it can never become unstable again. Stability is often reached @@ -16,9 +15,11 @@ A simple \gls{iTasks} example illustrating the route to stability of a Listing~\ref{lst:taskex}. The code is accompanied by screenshots showing the user interface in Figure~\ref{fig:taskex1},~\ref{fig:taskex2} and~\ref{fig:taskex3}. The \CI{TaskValue} of the \gls{Task} is in the first -image in the \CI{NoValue} state, the second and third image have an +image in the \CI{NoValue} state, the second image does not have all the fields +filled in and therefore the \CI{TaskValue} remains \CI{Unstable}. In the third +image all fields are entered and the \CI{TaskValue} transitions to the \CI{Unstable} state. When the user presses \emph{Continue} the value becomes -\CI{Stable}. +\CI{Stable} and cannot be changed any further. \begin{figure}[H] \centering @@ -41,6 +42,7 @@ enterName = enterInformation "Enter your name" [] \end{lstlisting} \begin{figure}[H] + \centering \begin{subfigure}{.25\textwidth} \centering \includegraphics[width=.9\linewidth]{taskex1} @@ -59,10 +61,82 @@ enterName = enterInformation "Enter your name" [] \caption{Example of a generated user interface} \end{figure} -For a type to be suitable it must have instances for a collection of generic -functions that are captured in the class \CI{iTask}. Basic types have +For a type to be suitable, it must have instances for a collection of generic +functions that is captured in the class \CI{iTask}. Basic types have specialization instances for these functions and show an according interface. Generated interfaces can be modified with decoration operators. -\subsection{Combinators} -\todo{Stukje over combinators, in ieder geval bind en paralel} +\section{Combinators} +\todo{check and refine} +\Glspl{Task} can be combined using so called \gls{Task}-combinators. +Combinators describe relations between \glspl{Task}. \Glspl{Task} can be +combined in parallel, sequenced and their result values can be converted to +\glspl{SDS}. Moreover, a very important combinator is the step combinator which +starts a new task according to specified predicates on the \CI{TaskValue}. +Type signatures of the basic combinators are shown in +Listing~\ref{lst:combinators}. + +\begin{itemize} + \item Step: + + The step combinator is used to start \glspl{Task} when a predicate on + the \CI{TaskValue} holds or an action has taken place. The bind + operator can be written as a step combinator. + \begin{lstlisting}[language=Clean] +(>>=) infixl 1 :: (Task a) (a -> (Task b)) -> (Task b) | iTask a & iTask b +(>>=) ta f = ta >>* [OnAction "Continue" onValue, OnValue onStable] + where + onValue (Value a _) = Just (f a) + onValue _ = Nothing + + onStable (Value a True) = Just (f a) + onStable _ = Nothing + \end{lstlisting} + \item Parallel: + + The parallel combinator allows for concurrent \glspl{Task}. The + \glspl{Task} combined with these operators will appear at the same time + in the web browser of the user and the results are combined as the type + dictates. +\end{itemize} + +\begin{lstlisting}[language=Clean,% + caption={\Gls{Task}-combinators},label={lst:combinators}] +//Step combinator +(>>*) infixl 1 :: (Task a) [TaskCont a (Task b)] -> Task b | iTask a & iTask b +(>>=) infixl 1 :: (Task a) (a -> Task b) -> Task b | iTask a & iTask b +:: TaskCont a b + = OnValue ((TaskValue a) -> Maybe b) + | OnAction Action ((TaskValue a) -> Maybe b) + | E.e: OnException (e -> b) & iTask e + | OnAllExceptions (String -> b) +:: Action = Action String + +//Parallel combinators +(-||-) infixr 3 :: (Task a) (Task a) -> Task a | iTask a +(||-) infixr 3 :: (Task a) (Task b) -> Task b | iTask a & iTask b +(-||) infixl 3 :: (Task a) (Task b) -> Task a | iTask a & iTask b +(-&&-) infixr 4 :: (Task a) (Task b) -> Task (a,b) | iTask a & iTask b +\end{lstlisting} + +\section{Shared Data Sources} +\Glspl{SDS} are an abstraction over resources that are available in the world +or in the \gls{iTasks} system. The shared data can be a file on disk, it can be +the time, a random integer or just some data stored in memory. The actual +\gls{SDS} is just a record containing functions on how to read and write the +source. In these functions the \CI{*World} is available and therefore it can +interact with the outside world. The \CI{*IWorld} is also available and +therefore the functions can also access other shares, possibly combining them. + +The basic operations for \glspl{SDS} are get, set and update. The signatures +for these functions are shown in Listing~\ref{lst:shares}. All of the +operations are atomic in the sense that during reading no other tasks are +executed. + +\begin{lstlisting}[% + language=Clean,label={lst:shares},caption={\Gls{SDS} functions}] +get :: (ReadWriteShared r w) -> Task r | iTask r +set :: w (ReadWriteShared r w) -> Task w | iTask w +upd :: (r -> w) (ReadWriteShared r w) -> Task w | iTask r & iTask w + +\end{lstlisting}