Remove todo.

[matthijs/master-project/report.git] / Chapters / Prototype.tex

diff --git a/Chapters/Prototype.tex b/Chapters/Prototype.tex
index 78f5ecfb85047a16c4f02e3dd31f5023c1c5e513..b9e8aa73e2a88d5de0e5ebb139158842a8ce91d6 100644 (file)
--- a/Chapters/Prototype.tex
+++ b/Chapters/Prototype.tex
@@ -51,8 +51,6 @@
     primary compiler, \GHC, provides a high level API to its internals, made
     Haskell an obvious choice.
 
-    \note{There should be evaluation of the choice of Haskell and \VHDL}
-
   \section[sec:prototype:output]{Output format}
     The second important question is: What will be our output format? Since
     our prototype won't be able to program FPGA's directly, we'll have to have
@@ -271,23 +269,23 @@
     \startdesc{Variable reference}
       \defref{variable reference}
       \startlambda
-      x
+      x :: T
       \stoplambda
       This is a reference to a binder. It's written down as the
-      name of the binder that is being referred to, which should of course be
-      bound in a containing scope (including top level scope, so a reference
-      to a top level function is also a variable reference). Additionally,
-      constructors from algebraic datatypes also become variable references.
+      name of the binder that is being referred to along with its type. The
+      binder name should of course be bound in a containing scope (including
+      top level scope, so a reference to a top level function is also a
+      variable reference). Additionally, constructors from algebraic datatypes
+      also become variable references.
 
       The value of this expression is the value bound to the given binder.
 
-      Each binder also carries around its type, but this is usually not shown
-      in the Core expressions. Occasionally, the type of an entire expression
-      or function is shown for clarity, but this is only informational. In
-      practice, the type of an expression is easily determined from the
-      structure of the expression and the types of the binders and occasional
-      cast expressions. This minimize the amount of bookkeeping needed to keep
-      the typing consistent.
+      Each binder also carries around its type (explicitly shown above), but
+      this is usually not shown in the Core expressions. Only when the type is
+      relevant (when a new binder is introduced, for example) will it be
+      shown. In other cases, the binder is either not relevant, or easily
+      derived from the context of the expression. \todo{Ref sidenote on type
+      annotations}
     \stopdesc
 
     \startdesc{Literal}
@@ -666,12 +664,12 @@
         instance declaration. This dictionary, as well as the binder
         introduced by a lambda that introduces a dictionary, have the
         predicate type as their type. These binders are usually named starting
-        with a \lam{$}. Usually the name of the type concerned is not
+        with a \lam{\$}. Usually the name of the type concerned is not
         reflected in the name of the dictionary, but the name of the type
         class is. The Haskell expression \hs{show True} thus becomes:
 
         \startlambda
-        show @Bool $dShow True
+        show @Bool \$dShow True
         \stoplambda
       \stopdesc
 
@@ -681,6 +679,10 @@
       here)}.
         
   \section[sec:prototype:statetype]{State annotations in Haskell}
+    As noted in \in{section}[sec:description:stateann], Cλash needs some
+    way to let the programmer explicitly specify which of a function's
+    arguments and which part of a function's result represent the
+    function's state.
       \fxnote{This entire section on state annotations should be reviewed}
 
       Ideal: Type synonyms, since there is no additional code overhead for