%&long
\begin{document}
-\frame{\titlepage}
+
+\maketitle
+
+\tableofcontents
\section{Introduction}
-\begin{frame}
- \frametitle{Scientific Impact}
- \begin{block}{Metrics}
- \begin{itemize}[<+->]
- \item Cited $676$ times in $23$ years
- \item $\pm 30$ cites per year
- \item Cited as de-facto monad introducing paper
- \item Monads in computer science: Moggi et al.\ in $1989$
- \end{itemize}
- \end{block}
-\end{frame}
-
-\begin{frame}
- \frametitle{Objective \& Current state}
- \begin{block}{Objective}
- \begin{itemize}
- \item First introduction to monads
- \item Layman's terms
- \end{itemize}
- \end{block}
-
- \pause%
- \begin{block}{Current state of the art}
- \begin{itemize}[<+->]
- \item $2016$: $2$ papers citing Wadler
- \item $2015$: $24$ papers citing Wadler
- \item Ranging from
- \begin{itemize}[<+->]
- \item Introducing new monad types
- \item Generic programming
- \item Designing modular DSL's
- \item Concurrency frameworks in functional languages
- \item\ldots
- \end{itemize}
- \end{itemize}
- \end{block}
-\end{frame}
-
-\section{Contents}
-\subsection{Introduction}
-\begin{frame}
- \frametitle{Introduction}
- \begin{itemize}
- \item Monads (Moggi et al.)
- \item Integrate the impure in the pure
- \item Wadler shows \textsc{Haskell} examples
- \item Following samples are in \textsc{Clean}
- \end{itemize}
-\end{frame}
-
-\subsection{Naive approach}
-\begin{frame}[fragile]
- \frametitle{Case study (1)}
- \framesubtitle{Evaluator}
- \begin{CleanCode}
+\subsection{Setting and objective}
+\emph{Monads for functional programming} was initially published in
+\emph{Program Design Calculi} which was a collection of lecture notes
+accompanying the \emph{Marktoberdorf} summer school in 1992. Later it was
+reissued in \emph{Springer}s \emph{Advanced Functional Programming} book which
+presents the tutorials from a spring school in Sweden in 1995.
+
+The notes were written to introduce the reader to the idea of a Monad usable in
+a functional programming context. Where monads are already defined and studied
+in category theory in the early fifties. Moggi et al.\ were the first in 1988
+to see the usefulness in computer science and in particular functional
+programming. At the time of writing this paper was introducing state of the art
+research which later became the preferred way of dealing with side-effects in a
+pure language. The paper familiarized readers with the concepts while only
+requiring basic knowledge in functional programming.
+
+\subsection{Impact}
+While Wadler had already published a lot about monads this turned out to be one
+of the most accessible and readable papers concerning the topic. A lot of the
+references in the paper cite his own work, but this is logical since he was
+part of the small group of researchers that kick-started the use of monads in
+functional programming.
+
+The paper has been cited over $676$ times over the past $23$ years resulting in
+a $\pm 30$ cites per year. It is cited as the de-facto monad introducing paper.
+In 2015 and 2016 the paper has already been cited numerous times in topics
+including but not limited to: Introducing new monad types, generic programming,
+designing modular design specific languages, concurrency frameworks in
+functional languages and probabilistic computing.
+
+\section{Proposal and evidence}
+\subsection{Proposal}
+Wadler proposes to capture side-effects in monads. A monad is a structure
+containing a monad type:
+\CI{:: M a}\\
+Secondly a monad contains a function to lift a value to the monadic domain:
+\CI{unit :: a -> M a}\\
+Lastly a monad contains the function that transforms \CI{a} into \CI{b} while
+capturing the possible side-effects in \CI{M}:
+\CI{(>>=) infixl 1 :: (M a) (a -> M b) -> M b}
+
+When this structure adheres certain laws they are very useful in capturing
+side-effects that would otherwise be difficult to handle in an impure language.
+Wadler shows this by tackling several classical problems arising in the pure
+functional programming world.
+
+\subsection{\emph{Expression problem}}
+In this review we will show one of the examples given to illustrate the meaning
+and usage the monadic pattern. The code snippets in the original paper
+supposedly are \emph{haskell} however they are not all valid. Thus the
+following snippets have been translated to valid
+\emph{Clean}~\footnote{\url{http://clean.cs.ru.nl}}
+
+\paragraph{Simple evaluator}
+Say we have a simple evaluator where an expression is either an integer or a
+division between two expressions. Writing a simple evaluator is very straight
+forward.
+\begin{CleanCode}
:: Term = Con Int | Div Term Term
eval :: Term -> Int
eval (Con a) = a
eval (Div t u) = eval t / eval u
-//Examples
answer :: Term
-answer = (Div (Div (Con 1972) (Con 2)) (Con 23))
+answer = Div (Div (Con 1972) (Con 2)) (Con 23)
error :: Term
error = (Div (Con 1) (Con 0))
- \end{CleanCode}
-\end{frame}
-
-\begin{frame}[fragile]
- \frametitle{Case study (2)}
- \framesubtitle{Exceptions}
- \begin{CleanCode}
+\end{CleanCode}
+
+\paragraph{Exceptions}
+When we evaluate \CI{eval error} we get a runtime exception since dividing by
+zero is illegal. If we want to add exceptions things get a little more frisky.
+We extend the type with an exception type that either contains an exception
+or a return value. The following code will catch exceptions nicely.
+\begin{CleanCode}
:: M a = Raise Exception | Return a
:: Exception :== String
eval :: Term -> M Int
-eval (Con a) = Return a
+eval (Con a) = return a
eval (Div t u) = case eval t of
Raise e = Raise e
Return a = case eval u of
Raise e = Raise e
- Return b = if (b == 0)
- (Raise "Divide by zero")
- (Return (a / b))
- \end{CleanCode}
-\end{frame}
-
-\begin{frame}[fragile]
- \frametitle{Case study (3)}
- \framesubtitle{State, count divisions}
- \begin{CleanCode}
+ Return b = if (b == 0) (Raise "Divide by zero") (Return (a/b))
+\end{CleanCode}
+
+\paragraph{State}
+Say we want to add state to the evaluator. Now we have to redo the entire
+evaluation part again. Say we have single integer as a state which counts the
+number of divisions taken. Then we get the following code which counts the
+number of divisions.
+\begin{CleanCode}
:: M a :== State -> (a, State)
:: State :== Int
eval :: Term -> M Int
-eval (Con a) x = (a, x)
-eval (Div t u)
-# (a, y) = eval t x
-# (b, z) = eval u y
-= (a/b, z+1)
- \end{CleanCode}
-\end{frame}
-
-\subsection{Monadic approach}
-\begin{frame}[fragile]
- \frametitle{Monadic (1)}
- Monad is a triple: $(M, unit, \star)$
- \pause%
- \begin{block}{Signatures}
- \begin{CleanCode}
-:: M a = ...
-unit :: a -> M a
-((#$\star$#)) infixl 1 :: (M a) (a -> M b) -> M b
- \end{CleanCode}
- \end{block}
- \pause%
- \begin{block}{Evaluator (Identity monad)}
- \begin{CleanCode}
-:: M a :== a
-unit :: a -> a
-unit a = a
-((#$\star$#)) infixl 1 :: (M a) (a -> M b) -> M b
-((#$\star$#)) a k = k a
- \end{CleanCode}
- \end{block}
-\end{frame}
-
-\begin{frame}[fragile]
- \frametitle{Monadic (2)}
- \framesubtitle{Exceptions}
- \pause%
- \begin{CleanCode}
+eval (Con a) = \x.(a, x)
+eval (Div t u) =
+ \x.let (a, y) = eval t x in
+ let (b, z) = eval u y in
+ (a/b, z+1)
+\end{CleanCode}
+
+\subsection{A monadic approach to the \emph{Expression problem}}
+\paragraph{Exceptions}
+The example for exceptions can be implemented using monads as follows:
+\begin{CleanCode}
:: M a = Raise Exception | Return a
:: Exception :== String
- \end{CleanCode}
- \pause%
- \begin{CleanCode}
+
unit :: a -> M a
unit a = Return a
-((#$\star$#)) infixl 1 :: (M a) (a -> M b) -> M b
-((#$\star$#)) m k = case m of
+(>>=) infixl 1 :: (M a) (a -> M b) -> M b
+(>>=) m k = case m of
Raise e = Raise e
Return a = k a
- \end{CleanCode}
- \pause%
- \begin{CleanCode}
+
raise :: Exception -> M a
raise e = Raise e
- \end{CleanCode}
-\end{frame}
-
-\begin{frame}[fragile]
- \frametitle{Monadic (3)}
- \framesubtitle{State}
- \pause%
- \begin{CleanCode}
-:: M a = State -> (a, State)
+
+eval :: Term -> M Int
+eval (Con a) = unit a
+eval (Div t u) = eval t >>= \a->eval u >>= \b->case b of
+ 0 = Raise "Divide by zero"
+ b = unit (a/b)
+\end{CleanCode}
+
+\paragraph{State}
+The example for states can be implemented using monads as follows:
+\begin{CleanCode}
+:: Void = Void
+:: M a :== State -> (a, State)
:: State :== Int
- \end{CleanCode}
- \pause%
- \begin{CleanCode}
+
unit :: a -> M a
-unit a = \x.(a, x)
+unit a = \x->(a, x)
-((#$\star$#)) infixl 1 :: (M a) (a -> M b) -> M b
-((#$\star$#)) m k = \x.let (a, y) = m x in
+(>>=) infixl 1 :: (M a) (a -> M b) -> M b
+(>>=) m k = \x->let (a, y) = m x in
let (b, z) = k a y in
(b, z)
- \end{CleanCode}
- \pause%
- \begin{CleanCode}
+
tick :: M Void
-tick = \x.(Void, x + 1)
- \end{CleanCode}
-\end{frame}
-
-\subsection{Laws}
-\begin{frame}[fragile]
- \frametitle{Laws}
- \begin{block}{Monoid}
- \begin{itemize}
- \item Left unit:
- \begin{CleanCode}
-unit a (#$\star$#) \b.n = n[a/b]
- \end{CleanCode}
- \item Right unit
- \begin{CleanCode}
-m (#$\star$#) \a.unit a = m
- \end{CleanCode}
- \item Associativity
- \begin{CleanCode}
-m (#$\star$#) (\a.n (#$\star$#) \b.o) = (m (#$\star$#) \a.n) (#$\star$#) \b.o
- \end{CleanCode}
- \end{itemize}
- \end{block}
-\end{frame}
-
-\subsection{Further evidence}
-\begin{frame}[fragile]
- \frametitle{Different approach}
- \framesubtitle{Parsers (1)}
- \begin{CleanCode}
-:: M a = State -> [(a, State)]
-:: State :== [Char]
+tick = \x->(Void, x+1)
-unit :: a -> M a
-unit a = \x.[(a, x)]
-
-((#$\star$#)) infixl 1 :: (M a) (a -> M b) -> M b
-((#$\star$#)) m k = \x.[(b, z) \\ (a, y) <- m x, (b, z) <- k a y]
- \end{CleanCode}
-\end{frame}
-
-\begin{frame}[fragile]
- \frametitle{Different approach}
- \framesubtitle{Parsers (2)}
- \begin{CleanCode}
-zero :: M a
-zero = \x.[]
-
-((#$\oplus$#)) infixl 4 :: (M a) (M a) -> M a
-((#$\oplus$#)) m n = \x.m x ++ n x
-
-((#$\triangleright$#)) infixl 4 :: (M a) (a -> Bool) -> M a
-((#$\triangleright$#)) m p = m (#$\star$#) \a.if (p a) (unit a) zero
-
-item :: M Char
-item = \x.case x of
- [] = []
- [a:x] = [(a, x)]
- \end{CleanCode}
-\end{frame}
-
-\begin{frame}[fragile]
- \frametitle{Different approach}
- \framesubtitle{Parsers (3)}
- \begin{CleanCode}
-iterate :: M a -> M [a]
-iterate m = (m (#$\star$#) \a.iterate m (#$\star$#) \x.unit [a:x]) (#$\oplus$#) unit []
-
-iterate (item (#$\triangleright$#) isDigit) "23 and more"
-[([2,3], " and more"), ([2], "3 and more"), ([], "23 and more")]
- \end{CleanCode}
- \pause
- \begin{CleanCode}
-((#$\oslash$#)) infixl 4 :: (M a) (M a) -> M a
-((#$\oslash$#)) m n = \x.if (m x <> []) (m x) (n x)
- \end{CleanCode}
-\end{frame}
-
-\section{Discussion}
-\begin{frame}
- \begin{block}{Writing style}
- \begin{itemize}[<+->]
- \item Pleasure to read
- \item Classical problems
- \item Fancy words
- \end{itemize}
- \end{block}
- \pause
- \begin{block}{Discussion queries}
- \begin{itemize}[<+->]
- \item Toy implementations, bigger?
- \item Would the last section about parsers be a paper on its own?
- \end{itemize}
- \end{block}
-\end{frame}
-
-\begin{frame}
- \frametitle{Questions or discussion points?}
-\end{frame}
+eval :: Term -> M Int
+eval (Con a) = unit a
+eval (Div t u) = eval t >>= \a->eval u >>= \b->tick >>= \_->unit (a/b)
+\end{CleanCode}
+
+\subsection{Evidence}
+Besides the example shown above Wadler shows also shows the usefulness of
+monads in a setting where you use lists, arrays and recursive descent parsers.
+These examples show the flexibility and ease that monads bring. Especially for
+input/output the monadic pattern is useful. If one wants to capture
+side-effects, instead of reimplementing every function for the particular side
+effects you can just write the monadic operations and let the monads handle the
+rest.
+
+Even after more than 20 years the monadic pattern is used throughout the
+functional programming world and is incorporated in all the functional
+programming languages used by the academic and by everyday programmers such as
+\emph{Haskell} and \emph{Clean}.
+
+\section{Analysis}
+\subsection{Writing style}
+The paper has been written for (under)-graduate students and thus it is
+extremely readable. Even with no particular domain knowledge the paper is very
+clear. The author tackles the expression problem, arrays as a state and parsers
+which are classical problems in the functional programming field. Even when the
+reader has little knowledge of functional programming those problems are
+familiar and are effective in illustrating the power of monads.
+
+\subsection{Discussion}
+Within the time frame of publishing these are near perfect publication, however
+in hindsight there are some things that could be improved upon.
+
+The language use is sometimes a bit informal and possibly even fluffy. However,
+the fact that these were originally lecture notes for a summer school clear
+this issue up.
+
+Secondly the section about parsers is quite big and not might not be necessary
+for illustrating the power of monads. The contents of this section could very
+well be a paper on its own.
\end{document}
repositories / rsss1516.git / commitdiff