Update outline.

diff --git a/Chapters/HardwareDescription.tex b/Chapters/HardwareDescription.tex
index ddce85dedbbc147263b481f42eff8408a924caf7..9e4061c9a4d059ee7fd8182c9d1e04565ecf94df 100644 (file)
--- a/Chapters/HardwareDescription.tex
+++ b/Chapters/HardwareDescription.tex
@@ -244,7 +244,7 @@ and3 a b c = and (and a b) c
         the prototype, which uses \emph{type families}.
       \stopdesc
 
         the prototype, which uses \emph{type families}.
       \stopdesc
 

-      TODO: Reference Christiaan
+      TODO: Reference Christiaan / describe dependent typing

     \subsection{User-defined types}
       There are three ways to define new types in Haskell: Algebraic
       datatypes with the \hs{data} keyword, type synonyms with the \hs{type}
     \subsection{User-defined types}
       There are three ways to define new types in Haskell: Algebraic
       datatypes with the \hs{data} keyword, type synonyms with the \hs{type}

diff --git a/Outline b/Outline
index 074f6a6105a1ee1b20fa1944352d8f685b5717df..88cc626ef3c0de6a81510995636ef59780012cdd 100644 (file)
--- a/Outline
+++ b/Outline
@@ -8,32 +8,26 @@ Introduction
 
 Haskell as hardware
 *       Simple function -> component interpretation (Model: Structure)
 
 Haskell as hardware
 *       Simple function -> component interpretation (Model: Structure)

+*       Choice / Case
+*       Types

 *       Partial application
 *       Model: State
 *         Explicit vs implicit passing of state (e.g, delay)
 *         Explicit vs implicit marking
 *       Interpret: Polymorphism
 *       Interpret: Higher order
 *       Partial application
 *       Model: State
 *         Explicit vs implicit passing of state (e.g, delay)
 *         Explicit vs implicit marking
 *       Interpret: Polymorphism
 *       Interpret: Higher order

-       Need: Dependent types

 *       Recursion
 *       Recursion

-       Impossible things: Infinite recursion, higher order expressions,
-                           recursive types, ...

 
 Prototype
 *       Choice of Haskell
 
 Prototype
 *       Choice of Haskell

-        VHDL / Verilog / EDIF etc. Why VHDL?
+*       VHDL / Verilog / EDIF etc. Why VHDL?

 *      Stages (-> Core, Normalization, -> VHDL)
 *      Stages (-> Core, Normalization, -> VHDL)

-.       Core - description of the language (appendix?)
+.       Core - description of the language
+*         Expressions
+          Typing

         Implementation issues -- Which?
         State annotations
 
         Implementation issues -- Which?
         State annotations
 

-        Haskell language coverage / constraints
-                Recursion
-                Builtin types
-                Custom types (Sum types, product types)
-                Function types / higher order expressions
-                State type -> Anything representable
-

 Normalization
 *      Normal form
 *      Rules used
 Normalization
 *      Normal form
 *      Rules used


@@ -48,5 +42,9 @@ Future work
 *      Multiple cycle descriptions
 *       Higher order state
 *       New language
 *      Multiple cycle descriptions
 *       Higher order state
 *       New language

+        Don't care

 
 TODO: Define user / developer
 
 TODO: Define user / developer

+TODO: Comiler vs translator
+TODO: Hardware description / model vs program
+TODO: State & pattern matches