X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Freport.git;a=blobdiff_plain;f=Outline;h=3ab4e6e0f748975bd0ad726e573de19313975e6a;hp=074f6a6105a1ee1b20fa1944352d8f685b5717df;hb=58a5aa7ca5edc07ba1070f4f4ed384b42e36e8f3;hpb=72edba19e4b745b8aa064ebd4f105d01a6055d8b

diff --git a/Outline b/Outline
index 074f6a6..3ab4e6e 100644
--- a/Outline
+++ b/Outline
@@ -8,45 +8,56 @@ Introduction
 
 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
-	Need: Dependent types
 *       Recursion
-	Impossible things: Infinite recursion, higher order expressions,
-                           recursive types, ...
 
 Prototype
 *       Choice of Haskell
-        VHDL / Verilog / EDIF etc. Why VHDL?
+*       VHDL / Verilog / EDIF etc. Why VHDL?
 *	Stages (-> Core, Normalization, -> VHDL)
-.       Core - description of the language (appendix?)
+.       Core - description of the language
+*         Expressions
+          Typing
         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
 .	Properties / Proofs (termination, soundness, completeness, determinism)
-	Casts / Strictness / Casebinders not fully supported
 
 Future work
-.	Boilerplate reduction (State distribution & pipelining)
+*	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: Hardware description / model vs program
+TODO: Separate compilation / Prelude
+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: Say something about implementation differences with transformation specs
+TODO: Say something about the builtin functions somewhere (ref: christiaan)
+TODO: Future work: Use Cλash
+TODO: Abstract
+TODO: Preface
+TODO: Footnote font has not lambda
+TODO: Top level function -> top level binder