Rename example function app2 to twice.
[matthijs/master-project/report.git] / Outline
diff --git a/Outline b/Outline
index 38383b8..7a18303 100644 (file)
--- a/Outline
+++ b/Outline
@@ -1,44 +1,63 @@
-Context
-  Other FHDLs (short, Christiaan has details)
-
-  Advantages of clash / why clash?
-
-  VHDL / Verilog / EDIF etc. Why VHDL?
+Introduction
+*       Goals
+*       Outline
 
+*Context
+*       Other FHDLs (short, Christiaan has details)
+*       Advantages of clash / why clash?
 
 Haskell as hardware
-        Simple function -> component interpretation (Model: Structure)
-        Model: State
-          Explicit vs implicit passing of state (e.g, delay)
-          Explicit vs implicit marking
-        Interpret: Polymorphism
-        Interpret: Higher order
-       Need: Dependent types
-       Impossible things: Infinite recursion, higher order expressions
+*       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
+*       Recursion
 
 Prototype
-        Choice of Haskell
-        Core - description of the language (appendix?)
-       Stages (-> Core, Normalization, -> VHDL)
-        Implementation issues
-
-        Haskell language coverage / constraints
-                Recursion
-                Builtin types
-                Custom types (Sum types, product types)
-                Function types / higher order expressions
+*       Choice of Haskell
+*       VHDL / Verilog / EDIF etc. Why VHDL?
+*      Stages (-> Core, Normalization, -> VHDL)
+.       Core - description of the language
+*         Expressions
+          Typing
+        Implementation issues -- Which?
+        State annotations
 
 Normalization
-       Normal form
-       Rules used
-       Completeness / conditions on input
-       Termination
-       Casts
+*      Normal form
+*      Rules used
+.      Properties / Proofs (termination, soundness, completeness, determinism)
 
 Future work
-       Boilerplate reduction (State distribution & pipelining)
-       Recursion
-       Multiple time domains (Events)
-       Multiple cycle descriptions
-        Higher order state
-        New language
+*      Boilerplate reduction (State distribution & pipelining)
+*      Recursion
+*       Multiple time domains (Events) -- Also, clock line optimization /
+                                       -- write enable
+*      Multiple cycle descriptions
+*       Higher order state
+*       New language
+        Don't care
+
+TODO: Define user / developer
+TODO: Comiler vs translator
+TODO: Hardware description / model vs program
+TODO: State & pattern matches
+TODO: Separate compilation / Prelude
+TODO: Add case binder removal transformation
+TODO: Remove all "statement"s
+TODO: User-defined type classes (future work?)
+TODO: Entity / Architecture / Component vs Function?
+TODO: Expand on "representable"
+TODO: Register
+TODO: Variable vs binder
+TODO: simplification -> Normalisation?
+TODO: Use saturated (application) instead of complete (application)?
+TODO: core => Core
+TODO: \defref{beta-reduction} -> \defref{β-reduction}
+TODO: Make interaction links not bold
+TODO: Say something about implementation differences with transformation specs