X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Fdsd-paper.git;a=blobdiff_plain;f=c%CE%BBash.lhs;h=c690e8ebc148dccd999bf6da2ad4ec376d07d5d2;hp=886376648304d8550742b94de4148a53399dcbcd;hb=0e8500ea330813277f7cbea455b1760a9dad83c1;hpb=d8b9a02732239603a440bf060bdbe6db0522b981

diff --git "a/c\316\273ash.lhs" "b/c\316\273ash.lhs"
index 8863766..c690e8e 100644
--- "a/c\316\273ash.lhs"
+++ "b/c\316\273ash.lhs"
@@ -825,9 +825,10 @@ circuit~\cite{reductioncircuit} for floating point numbers.
         Algebraic datatypes with multiple constructors, but without any
         fields are essentially a way to get an enumeration-like type
         containing alternatives. Note that Haskell's \hs{Bool} type is also 
-        defined as an enumeration type, but we have a fixed translation for 
-        that. An example of such an enum type is the type that represents the
-        colors in a traffic light:
+        defined as an enumeration type, but that there a fixed translation for 
+        that type within the \CLaSH\ compiler. An example of such an 
+        enumeration type is the type that represents the colors in a traffic 
+        light:
         \begin{code}
         data TrafficLight = Red | Orange | Green
         \end{code}
@@ -842,14 +843,16 @@ circuit~\cite{reductioncircuit} for floating point numbers.
     \end{xlist}
 
   \subsection{Polymorphism}
-    A powerful construct in most functional languages is polymorphism, it 
-    allows a function to handle values of different data types in a uniform 
-    way. Haskell supports \emph{parametric polymorphism}~\cite{polymorphism}, 
-    meaning functions can be written without mention of any specific type and 
-    can be used transparently with any number of new types.
+    A powerful feature of most (functional) programming languages is 
+    polymorphism, it allows a function to handle values of different data 
+    types in a uniform way. Haskell supports \emph{parametric 
+    polymorphism}~\cite{polymorphism}, meaning functions can be written 
+    without mention of any specific type and can be used transparently with 
+    any number of new types.
 
     As an example of a parametric polymorphic function, consider the type of 
     the following \hs{append} function, which appends an element to a vector:
+    
     \begin{code}
     append :: [a|n] -> a -> [a|n + 1]
     \end{code}
@@ -873,7 +876,7 @@ circuit~\cite{reductioncircuit} for floating point numbers.
     type classes, where a class definition provides the general interface of a 
     function, and class instances define the functionality for the specific 
     types. An example of such a type class is the \hs{Num} class, which 
-    contains all of Haskell's numerical operations. A developer can make use 
+    contains all of Haskell's numerical operations. A designer can make use 
     of this ad-hoc polymorphism by adding a constraint to a parametrically 
     polymorphic type variable. Such a constraint indicates that the type 
     variable can only be instantiated to a type whose members supports the 
@@ -895,14 +898,15 @@ circuit~\cite{reductioncircuit} for floating point numbers.
     In \CLaSH, parametric polymorphism is completely supported. Any function 
     defined can have any number of unconstrained type parameters. The \CLaSH\ 
     compiler will infer the type of every such argument depending on how the 
-    function is applied. There is one exception to this: The top level 
-    function that is translated, can not have any polymorphic arguments (as 
-    they are never applied, so there is no way to find out the actual types 
-    for the type parameters).
+    function is applied. There is however one constraint: the top level 
+    function that is being translated can not have any polymorphic arguments. 
+    The arguments can not be polymorphic as they are never applied and 
+    consequently there is no way to determine the actual types for the type 
+    parameters.
 
     \CLaSH\ does not support user-defined type classes, but does use some
-    of the built-in type classes for its built-in function, such as: \hs{Num} 
-    for numerical operations, \hs{Eq} for the equality operators, and
+    of the standard Haskell type classes for its built-in function, such as: 
+    \hs{Num} for numerical operations, \hs{Eq} for the equality operators, and
     \hs{Ord} for the comparison/order operators.
 
   \subsection{Higher-order functions \& values}
@@ -913,19 +917,19 @@ circuit~\cite{reductioncircuit} for floating point numbers.
     function. The following example should clarify this concept:
     
     \begin{code}
-    negVector xs = map not xs
+    negateVector xs = map not xs
     \end{code}
 
-    The code above defines a function \hs{negVector}, which takes a vector of
-    booleans, and returns a vector where all the values are negated. It 
-    achieves this by calling the \hs{map} function, and passing it 
+    The code above defines the \hs{negateVector} function, which takes a 
+    vector of booleans, \hs{xs}, and returns a vector where all the values are 
+    negated. It achieves this by calling the \hs{map} function, and passing it 
     \emph{another function}, boolean negation, and the vector of booleans, 
     \hs{xs}. The \hs{map} function applies the negation function to all the 
     elements in the vector.
 
     The \hs{map} function is called a higher-order function, since it takes 
     another function as an argument. Also note that \hs{map} is again a 
-    parametric polymorphic function: It does not pose any constraints on the 
+    parametric polymorphic function: it does not pose any constraints on the 
     type of the vector elements, other than that it must be the same type as 
     the input type of the function passed to \hs{map}. The element type of the 
     resulting vector is equal to the return type of the function passed, which 
@@ -960,12 +964,14 @@ circuit~\cite{reductioncircuit} for floating point numbers.
     \end{code}
 
     Finally, higher order arguments are not limited to just built-in
-    functions, but any function defined in \CLaSH\ can have function
+    functions, but any function defined by a developer can have function
     arguments. This allows the hardware designer to use a powerful
     abstraction mechanism in his designs and have an optimal amount of
-    code reuse.
+    code reuse. The only exception is again the top-level function: if a 
+    function-typed argument is not applied with an actual function, no 
+    hardware can be generated.    
 
-    \comment{TODO: Describe ALU example (no code)}
+    % \comment{TODO: Describe ALU example (no code)}
 
   \subsection{State}
     A very important concept in hardware it the concept of state. In a