Outline

   1 Introduction
   2 *       Goals
   3 *       Outline
   4
   5 *Context
   6 *       Other FHDLs (short, Christiaan has details)
   7 *       Advantages of clash / why clash?
   8
   9 Haskell as hardware
  10 *       Simple function -> component interpretation (Model: Structure)
  11 *       Partial application
  12 *       Model: State
  13 *         Explicit vs implicit passing of state (e.g, delay)
  14 *         Explicit vs implicit marking
  15 *       Interpret: Polymorphism
  16 *       Interpret: Higher order
  17         Need: Dependent types
  18 *       Recursion
  19         Impossible things: Infinite recursion, higher order expressions,
  20                            recursive types, ...
  21
  22 Prototype
  23 *       Choice of Haskell
  24         VHDL / Verilog / EDIF etc. Why VHDL?
  25 *       Stages (-> Core, Normalization, -> VHDL)
  26 .       Core - description of the language (appendix?)
  27         Implementation issues -- Which?
  28         State annotations
  29
  30         Haskell language coverage / constraints
  31                 Recursion
  32                 Builtin types
  33                 Custom types (Sum types, product types)
  34                 Function types / higher order expressions
  35                 State type -> Anything representable
  36
  37 Normalization
  38 *       Normal form
  39 *       Rules used
  40 .       Properties / Proofs (termination, soundness, completeness, determinism)
  41         Casts / Strictness / Casebinders not fully supported
  42
  43 Future work
  44 .       Boilerplate reduction (State distribution & pipelining)
  45 *       Recursion
  46 *       Multiple time domains (Events) -- Also, clock line optimization /
  47                                        -- write enable
  48 *       Multiple cycle descriptions
  49 *       Higher order state
  50 *       New language
  51
  52 TODO: Define user / developer