+++
title = "Value definitions"
weight = 1
+++

A value definition defines the value of an identifier (which could be a
function). Value definitions are the meat of a BH program.

Value definitions consist of a type signature followed immediately by
one or more defining clauses:

```
topDefn   ::= valueDefn
valueDefn ::= varId :: ctxType ;
              {clause ; }
clause    ::= varId
              {apat }[ when guard ]= exp
```

The first line of a value definition is the type signature--- it simply
specifies that the identifier *varId* has the type *ctxType*. Subsequent
lines define the value, one clause at a time. The *varId*'s on the
left-hand side of the type signature and on the left-hand side of each
clause must all be the same, *i.e.,* they collectively define a single
*varId*.

Each clause defines part of the value, using pattern matching and
guards. If there are patterns (*apat*'s) present, then the *varId* being
defined is a function, and the patterns represent arguments to the
function. The *guard* is a list of arbitrary predicates that may use
identifiers bound in the patterns (see Section [7](fixme)).

The clause should be read as follows: if the function *varId* is applied to
arguments that match the corresponding *apat*'s (in which case,
identifiers in the *apat*'s are bound to the corresponding components of
the arguments), and if the predicates in the *guard* are true, then the
function returns the value of the expression *exp*.

Example:

```hs
wordSize :: Integer
wordSize = 16
```


This simply defines the identifier `wordSize` to have type `Integer` and
value 16.


Example:

```hs
not :: Bool -> Bool
not True = False
not False = True
```

This defines the classical Boolean negation function. The type signature
specifies that `not` is a function with argument type `Bool` and result
type `Bool`. After that, the first clause specifies that if the argument
matches the value `True` (*i.e.,* it *is* the value `True`), then it
returns `False`. The final clause specifies that if the argument is
`False` it returns `True`.


Example:

```hs
f :: Maybe Int -> Int -> Int
f (Just x) y when x > 10, Just y’ <- g y = x + y'
f _        _                             = 0
```

(If necessary, please first remember the definition of the `Maybe` type,
introduced in section [4.1](fixme)). The first line specifies that
`f` is a function
of two arguments, of type `Maybe Int` and `Int`, respectively, and that
its result has type `Int`. The second line specifies that if the first
argument has the form `Just x` (in which case let us call its component
`x`), if the second argument is anything (let us call it `y`), if `x`'s
value is greater than 10, if the result of applying `g` to `y` has the
form `Just y’` (in which case let us call the component `y’`), then the
result is the value of `x + y’`. In all other cases, the result is the
value 0. The bare underscores in the second line are *wild-card*
patterns that match anything (described in section
[6.1](fixme)).


Clauses are attempted in order, from top to bottom, proceeding to the
next clause only if the pattern matching and guard evaluation fail.
Within each clause, pattern matching and guard evaluation are attempted
from left to right. If no clause succeeds, then the system will raise a
"pattern matching error".