X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Freport.git;a=blobdiff_plain;f=Outline;h=4844ad214953ffc9d3d82b7096d40b606b79fa4f;hp=73246f9dc78177926933e61cfeb46677cee82dea;hb=23487a1fa3e35868cd9d838eb3c59d02ed5ebdac;hpb=c8b72a250403339e3782e3efebc02a11f2411182

diff --git a/Outline b/Outline
index 73246f9..4844ad2 100644
--- a/Outline
+++ b/Outline
@@ -1,41 +1,60 @@
-Implementation issues
+Introduction
+*       Goals
+*       Outline
 
-State
+*Context
+*       Other FHDLs (short, Christiaan has details)
+*       Advantages of clash / why clash?
 
-Prototype
-	Stages (-> Core, Normalization, -> VHDL)
-
-Core
+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
+*       Recursion
 
-VHDL vs EDIF generation
+Prototype
+*       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
-
-Context
-
-Other FHDLs
-
-VHDL / Verilog / EDIF etc.
-
-Advantages of clash / why clash?
-
-Haskell as hardware
-	Dependent types
-	Impossible things: Infinite recursion, higher order expressions
-
-Haskell language coverage / constraints
-	Recursion
-	Builtin types
-	Custom types (Sum types, product types)
-	Function types / higher order expressions
+*	Normal form
+*	Rules used
+.	Properties / Proofs (termination, soundness, completeness, determinism)
 
 Future work
-	Boilerplate reduction (State distribution & pipelining)
-	Recursion
-	Multiple time domains
-	Multiple cycle descriptions
+*	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: 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