Updated part about polymorhism, now mentions the types of polymorphism by their corre...

diff --git a/clash.bib b/clash.bib
index dbb6b1cc7c85a29549e443998430f06702ffb4e2..dee55325f1d7ac5bc95ffdbb1909a7224bcdd34e 100644 (file)
--- a/clash.bib
+++ b/clash.bib
@@ -1,4 +1,4 @@
-% This file was created with JabRef 2.4.2.
+% This file was created with JabRef 2.5.
 % Encoding: MacRoman
 
 @INPROCEEDINGS{Wired,
@@ -286,6 +286,19 @@
   timestamp = {2010.01.20}
 }
 
+@MISC{polymorphism,
+  author = {Strachey, Christopher},
+  title = {Fundamental Concepts in Programming Languages},
+  howpublished = {Lecture Notes, International Summer School in Computer Programming,
+       Copenhagen},
+  month = August,
+  year = {1967},
+  note = {Reprinted in {\em Higher-Order and Symbolic Computation}, 13(1/2),
+       pp. 1--49, 2000},
+  owner = {baaijcpr},
+  timestamp = {2010.02.24}
+}
+
 @BOOK{Haskell,
   title = {{Haskell 98 language and libraries}},
   year = {2003},
@@ -318,11 +331,11 @@
   timestamp = {2010.01.29}
 }
 
-@comment{jabref-meta: selector_journal:}
+@comment{jabref-meta: selector_publisher:}
 
 @comment{jabref-meta: selector_author:}
 
-@comment{jabref-meta: selector_keywords:}
+@comment{jabref-meta: selector_journal:}
 
-@comment{jabref-meta: selector_publisher:}
+@comment{jabref-meta: selector_keywords:}
 

diff --git a/cλash.lhs b/cλash.lhs
index eb7d1fff8a11e82981bbb3b68a084b04ac06813a..9c5e5bd182bfac3dc358414af7e15dfaa72b1fee 100644 (file)
--- a/cλash.lhs
+++ b/cλash.lhs
@@ -766,10 +766,8 @@ by any (optimizing) \VHDL\ synthesis tool.
     names for existing types, where synonyms are completely interchangeable 
     and renaming constructs need explicit conversions. Therefore, these do not 
     need any particular translation, a synonym or renamed type will just use 
-    the same representation as the original type. The distinction between a     
-    renaming and a synonym does no longer matter in hardware and can be     
-    disregarded in the translation process. For algebraic types, we can make     
-    the following distinction: 
+    the same representation as the original type. For algebraic types, we can 
+    make the following distinctions: 
 
     \begin{xlist}
       \item[\bf{Single constructor}]
@@ -803,65 +801,69 @@ by any (optimizing) \VHDL\ synthesis tool.
         currently supported.
     \end{xlist}
 
-  \subsection{Polymorphic functions}
-    A powerful construct in most functional language is polymorphism.
-    This means the arguments of a function (and consequentially, values
-    within the function as well) do not need to have a fixed type.
-    Haskell supports \emph{parametric polymorphism}, meaning a
-    function's type can be parameterized with another type.
-
-    As an example of a polymorphic function, consider the following
-    \hs{append} function's type:
-    
-    \comment{TODO: Use vectors instead of lists?}
+  \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.
 
+    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}
 
     This type is parameterized by \hs{a}, which can contain any type at
-    all. This means that append can append an element to a list,
-    regardless of the type of the elements in the list (but the element
-    added must match the elements in the list, since there is only one
-    \hs{a}).
-
-    This kind of polymorphism is extremely useful in hardware designs to
-    make operations work on a vector without knowing exactly what elements
-    are inside, routing signals without knowing exactly what kinds of
-    signals these are, or working with a vector without knowing exactly
-    how long it is. Polymorphism also plays an important role in most
-    higher order functions, as we will see in the next section.
-
-    The previous example showed unconstrained polymorphism \comment{(TODO: How 
-    is this really called?)}: \hs{a} can have \emph{any} type. 
-    Furthermore,Haskell supports limiting the types of a type parameter to 
-    specific class of types. An example of such a type class is the 
-    \hs{Num} class, which contains all of Haskell's numerical types.
-
-    Now, take the addition operator, which has the following type:
-
+    all. This means that append can append an element to a vector,
+    regardless of the type of the elements in the list (as long as the type of 
+    the value to be added is of the same type as the values in the vector). 
+    This kind of polymorphism is extremely useful in hardware designs to make 
+    operations work on a vector without knowing exactly what elements are 
+    inside, routing signals without knowing exactly what kinds of signals 
+    these are, or working with a vector without knowing exactly how long it 
+    is. Polymorphism also plays an important role in most higher order 
+    functions, as we will see in the next section.
+
+    Another type of polymorphism is \emph{ad-hoc 
+    polymorphism}~\cite{polymorphism}, which refers to polymorphic 
+    functions which can be applied to arguments of different types, but which 
+    behave differently depending on the type of the argument to which they are 
+    applied. In Haskell, ad-hoc polymorphism is achieved through the use of 
+    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 operation. A developer 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 
+    overloaded functions associated with the type class. 
+    
+    As an example we will take a look at type signature of the function 
+    \hs{sum}, which sums the values in a vector:
     \begin{code}
-    (+) :: Num a => a -> a -> a
+    sum :: Num a => [a|n] -> a
     \end{code}
 
     This type is again parameterized by \hs{a}, but it can only contain
-    types that are \emph{instances} of the \emph{type class} \hs{Num}.
-    Our numerical built-in types are also instances of the \hs{Num}
+    types that are \emph{instances} of the \emph{type class} \hs{Num}, so that  
+    we know that the addition (+) operator is defined for that type. 
+    \CLaSH's built-in numerical types are also instances of the \hs{Num}
     class, so we can use the addition operator on \hs{SizedWords} as
-    well as on {SizedInts}.
+    well as on \hs{SizedInts}.
 
-    In \CLaSH, unconstrained 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 (since it is never applied, so
-    there is no way to find out the actual types for the type
-    parameters).
+    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).
 
     \CLaSH\ does not support user-defined type classes, but does use some
-    of the builtin ones for its builtin functions (like \hs{Num} and
-    \hs{Eq}).
+    of the built-in type classes for its built-in function, such asL \hs{Num} 
+    for  numerical operations, \hs{Eq} for the equality operators, and
+    \hs{Ord} for the comparison/order operators.
 
   \subsection{Higher order}
     Another powerful abstraction mechanism in functional languages, is