X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Fdsd-paper.git;a=blobdiff_plain;f=c%CE%BBash.lhs;h=ca4f1cdc8ece28c34c6c457ee71477814747fc12;hp=58caa4bb9c3b75b0eab808ce1c27e296fa66fced;hb=a3f637b15eaa7eef95507963a0bc96bb18d844ae;hpb=d761eaf56b88d9a83aa096d23e12bb4d724d4c3f

diff --git "a/c\316\273ash.lhs" "b/c\316\273ash.lhs"
index 58caa4b..ca4f1cd 100644
--- "a/c\316\273ash.lhs"
+++ "b/c\316\273ash.lhs"
@@ -352,6 +352,20 @@
 \def\hs#1{\texttt{#1}}
 \def\quote#1{``{#1}"}
 
+\newenvironment{xlist}[1][\rule{0em}{0em}]{%
+  \begin{list}{}{%
+    \settowidth{\labelwidth}{#1:}
+    \setlength{\labelsep}{0.5cm}
+    \setlength{\leftmargin}{\labelwidth}
+    \addtolength{\leftmargin}{\labelsep}
+    \setlength{\rightmargin}{0pt}
+    \setlength{\parsep}{0.5ex plus 0.2ex minus 0.1ex}
+    \setlength{\itemsep}{0 ex plus 0.2ex}
+    \renewcommand{\makelabel}[1]{##1:\hfil}
+    }
+  }
+{\end{list}}
+
 %include polycode.fmt
 
 \begin{document}
@@ -573,7 +587,7 @@ sumif _ _ _ = 0
     others are defined by the \CLaSH\ package, so they are user-defined types
     from Haskell's point of view).
 
-    \begin{description}
+    \begin{xlist}
       \item[\hs{Bit}]
         This is the most basic type available. It is mapped directly onto
         the \texttt{std\_logic} \VHDL\ type. Mapping this to the
@@ -595,9 +609,9 @@ sumif _ _ _ = 0
         length type, so you can define an unsigned word of 32 bits wide as
         ollows:
 
-        \begin{verbatim}
-          type Word32 = SizedWord D32
-        \end{verbatim}
+\begin{verbatim}
+  type Word32 = SizedWord D32
+\end{verbatim}
 
         Here, a type synonym \hs{Word32} is defined that is equal to the
         \hs{SizedWord} type constructor applied to the type \hs{D32}. \hs{D32}
@@ -617,9 +631,9 @@ sumif _ _ _ = 0
         of the vector and the type of the elements contained in it. The state
         type of an 8 element register bank would then for example be:
 
-        \begin{verbatim}
-        type RegisterState = Vector D8 Word32
-        \end{verbatim}
+\begin{verbatim}
+type RegisterState = Vector D8 Word32
+\end{verbatim}
 
         Here, a type synonym \hs{RegisterState} is defined that is equal to
         the \hs{Vector} type constructor applied to the types \hs{D8} (The type
@@ -639,9 +653,9 @@ sumif _ _ _ = 0
 
         To define an index for the 8 element vector above, we would do:
 
-        \begin{verbatim}
-        type RegisterIndex = RangedWord D7
-        \end{verbatim}
+\begin{verbatim}
+type RegisterIndex = RangedWord D7
+\end{verbatim}
 
         Here, a type synonym \hs{RegisterIndex} is defined that is equal to
         the \hs{RangedWord} type constructor applied to the type \hs{D7}. In
@@ -650,7 +664,7 @@ sumif _ _ _ = 0
         8 element vector \hs{RegisterState} above.
 
         This type is translated to the \texttt{unsigned} \VHDL type.
-    \end{description}
+    \end{xlist}
   \subsection{User-defined types}
     There are three ways to define new types in Haskell: algebraic
     data-types with the \hs{data} keyword, type synonyms with the \hs{type}
@@ -671,8 +685,7 @@ sumif _ _ _ = 0
 
     For algebraic types, we can make the following distinction: 
 
-    \begin{description}
-
+    \begin{xlist}
       \item[Product types]
         A product type is an algebraic datatype with a single constructor with
         two or more fields, denoted in practice like (a,b), (a,b,c), etc. This
@@ -715,9 +728,9 @@ sumif _ _ _ = 0
         no obvious \VHDL\ alternative. They can easily be emulated, however, as
         we will see from an example:
 
-        \begin{verbatim}
-        data Sum = A Bit Word | B Word
-        \end{verbatim}
+\begin{verbatim}
+data Sum = A Bit Word | B Word
+\end{verbatim}
 
         An obvious way to translate this would be to create an enumeration to
         distinguish the constructors and then create a big record that
@@ -725,10 +738,10 @@ sumif _ _ _ = 0
         translation that would result from the following enumeration and
         product type (using a tuple for clarity):
 
-        \begin{verbatim}
-        data SumC = A | B
-        type Sum = (SumC, Bit, Word, Word)
-        \end{verbatim}
+\begin{verbatim}
+data SumC = A | B
+type Sum = (SumC, Bit, Word, Word)
+\end{verbatim}
 
         Here, the \hs{SumC} type effectively signals which of the latter three
         fields of the \hs{Sum} type are valid (the first two if \hs{A}, the
@@ -746,7 +759,7 @@ sumif _ _ _ = 0
         different types and could not be shared. However, in the final
         hardware, both of these types would simply be 8 bit connections,
         so we have a 100\% size increase by not sharing these.
-      \end{description}
+      \end{xlist}
 
 
 \section{\CLaSH\ prototype}