BSV by Example - Computation Structures Group

type-checking environment. Type checking, which occurs before program elaboration or execution,
ensures that object types are compatible and that conversion functions are valid for the context.
Data types in BSV are case sensitive. The first character of a type is always uppercase (there are
only two exceptions: the types int and bit, compatibility with Verilog). The first character of a
variable name is always lowercase. A common source of errors for beginners in BSV is to use an
uppercase name where BSV expects a lower case, and vice versa.
3.2 Uppercase and lowercase in type and value identifiers
In BSV, the case of the first letter of an identifier is significant, whether used to describe types
or values. The general principle is that an uppercase first letter introduces a constant, whereas a
lowercase first letter introduces a variable.
A constant type is a particular type, such as Bool, Int, UInt, Server, Action, Module, Rule, and
so on. A type variable is used to represent a polymorphic type, similar to “generic” or “template”
types in other languages (see Section 9 for more on polymorphism).
A constant value is a particular symbolic value, such as True, False, the symbolic labels declared
in all enum types, the constructors associated with any struct or tagged union type, and so on. A
type variable is the familiar identifier bound to some particular value, such as x, foo, mkTb, mkDut,
and so on.
3.3 Typeclasses and overloading
[This section can be skimmed lightly on first reading. Overloading is used in a fairly lightweight
manner in subsequent sections, for which this section provides some intuition and context.]
BSV makes very effective use of systematic, user-extensible overloading. For example, instead of
having ad hoc definitions of how various data types are represented in bits, in BSV each such data
type has a pair of overloaded functions called pack and unpack that convert from the abstract view
of the type into bits and vice versa. Further, because overloading is user-extensible, the user can
specify the definitions of these functions precisely, and thus specify representations precisely.
In BSV, we say that there is a“typeclass”called Bits#(t,n ), which can be regarded as a set of types.
Any type t in this typeclass has definitions for bit representation in n bits, i.e., it has definitions for
the overloaded functions:
function Bit#(n) pack (t x);
function t unpack (Bit#(n) b);
Each member type t in a typeclass is called an instance of the typeclass. The functions pack and
unpack are called overloaded because the same function names are used for different types, and the
compiler figures out the appropriate ones to use based on the actual types of their arguments and
results.
In most cases in the examples below, we will use a shortcut to define bit representations. Instead of
a full-blown instance declaration, you will often see the phrase “deriving (Bits)” appended to a
type definition, indicating to the compiler to pick the obvious, canonical bit representation. Thus,
we only write a full-blown instance declaration for Bits if we need a non-standard representation.
Thus, a typeclass is a construct which implements overloading across related data types. Overloading
is the ability to use a common function name or operator on a collection of types, with the specific
function or operator being selected by the compiler based on the types on which it is actually used
(this process is called “overloading resolution”). A typeclass may include multiple data types; all
data types within the typeclass share functions and operators, hence the function names within a
typeclass are overloaded across the various typeclass members.
24