Simple TypesSome types don't require any parameters to be fully specified. This are referred to as simple types.
Examples of simple types include:
Parameterized TypesOther types require one or more parameters to be defined, these are referred to as parameterized types. Type parameters can be natural numbers (also known as size types)
which indicate some aspect of the size of the type, such as a bit-width
or a table capacity. For example, you define a type as an Int#(n) the type parameter n indicates the width if the integer (how many bits wide). Some types have multiple parameters. A Vector
type has two parameters. The size type parameter indicates how many
items are in the Vector while the other parameter indicates the type of
the items contained in the Vector.
Examples of parameterized types:
Bit#(16)</code> // 16-bit wide bit-vector
UInt#(32) </code> // unsigned integers, 32 bits wide
Int#(29)</code> // signed integers, 29 bits wide
Vector#(16,Int#(29)</code> // Vector containing 16 items, each of which is an Int, 29 bits wide
Other examples of parameterized types:
Tuple2#(int,Bool)</code> // pair of items, an int and a Bool
Tuple3#(int,Bool,String)</code> // triple of items, an int, a Bool and a String
Listt#(Bool)</code> // list containing booleans
List#(List#(Bool))</code> // list containing lists of booleans
RegFile#(Integer, String)</code> // a register file (array) indexed by integers
// containing strings
Polymorphic Types
A parameterized type in which the parameter is represented by a specific (but unknown) type are referred to as polymorphic types. These are indicated by using type variables as parameters.
Examples of polymorphic types:
List#(a) // lists containing items of some type a
List#(List#(b)) // lists containing lists of items of some type a
RegFile#(i,
List#(x)) // arrays indexed by some type i, containing lists that
// contain
items of some type x
The type variables represent unknown (but specific) types. In other words, List#(a) represents the type of a list containing items all of which have some type a. It does not mean that different elements of a list can have different types. |
|
