\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}
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
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}
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
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
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}
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
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
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
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}
projects / matthijs / master-project / dsd-paper.git / blobdiff