Notities toegevoegd

[matthijs/master-project/final-presentation.git] / christiaan / recursion.lhs

diff --git a/christiaan/recursion.lhs b/christiaan/recursion.lhs
index 7732e2331fc6efdd1631762427ee12957d5c336e..c9349ab74a8d9e8021f594a9d9fcb2ff786181f9 100644 (file)
--- a/christiaan/recursion.lhs
+++ b/christiaan/recursion.lhs
@@ -8,6 +8,12 @@
   \item Unexplored solution: Haskell language extensions, new source language
 \end{itemize}
 }
+\note[itemize]{
+\item Afsluitend nog het meest voor de hand liggende future work: het ondersteunen van recursie.
+\item Er zijn al wat mogelijkheden onderzocht: static loop unrolling, waar ik zo wat over vertel.
+\item Andere mogelijkheden zijn het op zoek gaan naar een taal die wel echt ondersteuning heeft voor dependent types. Daar later meer over.
+\item Next sheet: static loop unrolling
+}
 
 \subsubsection{Static loop unrolling}
 \frame{
@@ -17,6 +23,11 @@
   \item Explored solution: Unrolling number-guided recursive functions using Template Haskell
 \end{itemize}
 }
+\note[itemize]{
+\item Static loop unrolling, is het op compile-time uitrollen van recursieve functies totdat er geen recursie meer is. Je moet de functies ook simplificeren omdat je de choice-logic die de recursie leidt wil verwijderen.
+\item Ik heb gekeken naar het uitrollen van number-guided recursive functies, met gehulp van Template Haskell.
+\item Next sheet: Template Haskell uitleg
+}
 
 \frame{
 \frametitle{Template Haskell}
@@ -25,25 +36,39 @@
   \item All these functions are expressible in normal Haskell
 \end{itemize}
 }
+\note[itemize]{
+\item Ik heb vooral naar Template Haskell gekeken, omdat toekomstig gebruikes van \clash{} ook beschikking hebben om TH te kunnen gebruiken. Zonder dat ze direct de compiler in moeten duiken.
+\item TH staat het toe om code op compile-time te inspecteren, te creeeren en te veranderen.
+\item En dit kan allemaal met behulp van normale Haskell code
+\item Next sheet: voorbeeld uitrollen tree adder
+}
 
 \frame{
 \frametitle{Tree Adder}
-\begin{verbatim}
+\begin{code}
 $(do
   [typ, _] <- [d|{
-treeSum :: Vector D8 (SizedWord D8) -> SizedWord D8;
+{-"{\color<2>[rgb]{1,0,0}"-}treeSum :: Vector D8 (SizedWord D8) -> SizedWord D8;{-"}"-}
 treeSum xs = undefined
   }|]
   [func] <- [d|{
-treeSum i xs | i < 1     = head xs
-             | otherwise = let (a,b) = split xs
-                           in (treeSum (i-1) a) + 
-                              (treeSum (i-1) b)
+{-"{\color<3>[rgb]{1,0,0}"-}treeSum i xs | i < 1     = head xs{-"}"-}
+{-"{\color<3>[rgb]{1,0,0}"-}             | otherwise = let (a,b) = split xs{-"}"-}
+{-"{\color<3>[rgb]{1,0,0}"-}                           in (treeSum (i-1) a) +{-"}"-} 
+{-"{\color<3>[rgb]{1,0,0}"-}                              (treeSum (i-1) b){-"}"-}
   }|]
-  let func' = unroll Nothing 0 (IntegerL 3) funct
-  return [typ,func']
+{-"{\color<4>[rgb]{1,0,0}"-}  let func' = unroll Nothing 0 (IntegerL 3) func{-"}"-}
+{-"{\color<5>[rgb]{1,0,0}"-}  return [typ,func']{-"}"-}
 )
-\end{verbatim}
+\end{code}
+}
+\note[itemize]{
+\item Zie hier een recursieve tree adder die ik uitroll naar 3 diep d.m.v. template haskell
+\item Zie de function signature bovenaan.
+\item Dan de de recursieve treeSum functie
+\item Dan de unroll functie die deze treeSum functie uitrolt
+\item En dan voegen we de uitegerolde functie weer in
+\item Next sheet: schema uitgerolde tree adder
 }
 
 \begin{frame}
@@ -52,6 +77,10 @@ treeSum i xs | i < 1     = head xs
       \includegraphics[height=5cm]{treeadder} 
     \end{figure}
 \end{frame}
+\note[itemize]{
+\item Hier een schema van uitgerolde tree-adder voor 3 diep
+\item Volgende sheet: Aanpassingen input taal voor \clash{}
+}
 
 \subsubsection{Input Language}
 \frame{
@@ -60,4 +89,10 @@ treeSum i xs | i < 1     = head xs
   \item New source language: One of the problems is that Haskell does not properly support dependent types. Investigate languages with dependent type systems.
   \item Haskell extentions: Invariant descriptions at the type-level.
 \end{itemize}
+}
+\note[itemize]{
+\item Ondersteuning van dependent types is niet echt bestaand in Haskell. Is meer op een ad-hoc manier mogelijk, maar is bij ontwerp van het type-systeem nooit de bedoeling geweest.
+\item Daarom zou er gekeken moeten worden naar een echte dependently typed taal. Die het hopelijk makkelijker maakt om invarianten te specificeren, en is toe te voegen aan de code.
+\item Of er moet worden gekeken of er in Haskell de mogelijkheid bestaat om invarianten op type-niveau toe te voegen.
+\item Next sheet: vragen
 }
\ No newline at end of file