[FMFP] Notes for examp prep

semester4/fmfp/parts/06_exercises/01_fp/01_haskell.tex

@@ -6,6 +6,26 @@
 \paragraph{Programming}
 The best tip here is to read the Haskell book, and to solve the exercises during the semester.
 
+Remember that application is left-associative (i.e. \texttt{func x y} parenthesized is \texttt{(func x) y}, even if \texttt{x} is a function).
+
+A handy to know shortening technique for functions is \texttt{Leaf . f} is equivalent to \texttt{leaf x = Leaf (f x)}.
+Thus, the \texttt{.} operator chains functions.
+
+For all functions with recursion, don't forget the base cases. In addition, for guards (i.e. statements with a pipe character (\texttt{|})),
+there is no equal sign before the pipe characters.
+For the cases notation, there are equal signs. We can use underscores as a ``don't care'' character.
+
+\subparagraph{Lists}
+In list comprehensions, to draw from a list, \texttt{<-} is used, to delimit the description of the list contents from the generator part, we use a pipe character
+and to separate each statement in the generator part, we use a comma.
+Remember that list comprehension does allow duplicates, so it is not entirely equivalent to sets.
+We can use the \texttt{nub} function from \texttt{Data.List} to remove duplicates.
+
+We can initialize infinite lists using the \texttt{..} syntax. We define the interval using \texttt{[1, 2..]}, or \texttt{[0, 0..]} to create an infinite lists of zeros.
+
+More advanced types can be ``disassembled'' like this: \texttt{Node x l r} for type \texttt{Node a (Tree x) (Tree x)}
+
+
 \subparagraph{Fold}
 One of the most important functions to understand is \texttt{foldr} (and \texttt{foldl}).
 If you have used \texttt{reduce} functions before, in e.g. JavaScript / TypeScript,
@@ -22,8 +42,14 @@ In the Haskell prelude, they are defined as follows:
 
     foldl :: (a -> b -> a) -> a -> [b] -> a
     foldl f z []     = z
-    foldl f z (x:xs) = foldl f (f v x) xs
+    foldl f z (x:xs) = foldl f (f z x) xs
 \end{code}
+When extending them to more complex data structures such as trees, we may need to add one function to the arguments per type of possible element in the data structure.
+Ideally, we first write the function, then infer its type.
+Remember that in the definition of these two functions, the \texttt{-> b ->} (and \texttt{-> a ->}, respectively) denote the type of the base case.
+
+For more elaborate data structures, the functions for each subtype should be in the same order as in the data type definition, for canonical definition of the fold function.
+
 
 \subparagraph{zipWith}
 To combine a \texttt{map} and a \texttt{zip} function, use \texttt{zipWith}, type:
@@ -32,4 +58,13 @@ To combine a \texttt{map} and a \texttt{zip} function, use \texttt{zipWith}, typ
 \TODO Add more remarks
 
 \paragraph{Proofs}
-These proofs use structural induction, see Section~\ref{sec:induction-proofs} for that.
+These proofs use structural induction, often it is easiest to use strong structural induction, see Section~\ref{sec:induction-proofs} for that.
+In many cases, generalizing the statement is what enables the proof. So whenever there is a constant, generalize the constant before doing the proof,
+as otherwise the proof will likely be hard to impossible to pull off under the time constraints.
+In that case, we set $P(t) \equiv \forall n \in \N_0$ the generalized statement, or equivalent.
+Remember:
+\begin{itemize}
+    \item for each case state the fixed variables (which are all free variables in this case)
+    \item in the base case / simple case, fix $n$
+    \item in the end state that since it holds for all $n$, it, in particular, holds for $n = 0$ (or equivalent)
+\end{itemize}

semester4/fmfp/parts/06_exercises/01_fp/03_type-inference.tex

@@ -5,6 +5,7 @@
 The proof trees are again drawn up bottom up, applying rules from the outside in.
 \begin{enumerate}
     \item Create a proof tree using the typing rules.
+          An easy way to avoid mistakes is to always write out the structure of each type in the tree.
     \item During the proof, keep track of what the applications of rules tell us about types in a list.
     \item After reaching leafs in the prooftree, resolve the types by inserting the now known types into the types you kept in the list.
 \end{enumerate}