Constructors and pattern matching

Constructors associated with classes have two important roles. First, they provide a way to create objects of a given class. Second, they are used as patterns, allowing to discover what constructor was used to create a given object and to access its fields.
Object construction
Constructors can be used as ordinary functions. They take as their arguments values for the fields (in order of declaration) and return an object of the given class. For example, the definition for Maybe class:
1
class Maybe a:
2
    Just a
3
    Nothing
Copied!
gives rise to two such values:
1
Just :: a -> Maybe a
2
Nothing :: Maybe a
Copied!
Note that since the Nothing constructor has no fields, it is not a function, it's a constant, that can assume the type Maybe a for any choice of a.
Pattern matching
The other use of constructors is for pattern matching. This allows to unpack an object into it's constituent fields, assuming the constructor used in pattern match is the same as the one assigned to the object. First of all, you may use patterns on the left-hand-side of assignment operator. This assigns the values of fields to the variables mentioned in the pattern. Let's see how this can be used with the Vector class defined like so:
1
class Vector:
2
    x y z :: Real
Copied!
1
myVec = Vector 1.0 2.0 3.0
2
Vector a b c = myVec
3
bTimesOne = b * 1.0
Copied!
You need to be careful with this construction though! It assumes that you have picked the right constructor and a mismatch will result in a runtime error. As a rule of thumb, you should use this form of pattern matching only on classes that have one constructor (thus making sure there is no possibility for an error).
Case expression
The case expression is the most general way to handle pattern matching. It is also generally the safest and when in doubt you should always resort to this form of pattern matching. It's a mechanism allowing to discover which particular constructor was used to create a given object and to provide a different value for each of the possibilities.
Let's get back to the Shape example once again. Suppose we have facilities for rendering circles and rectangles and we need to render general Shapes. This can be accomplished with a simple case expression:
1
def render shape:
2
    case shape of
3
        Circle c r: drawCircle c r
4
        Rectangle tl br: drawRectangle tl br
Copied!
The structure is pretty straightforward: first, between the case ... of we need to provide the object which identity we need to discover and then we provide a series of clauses, each providing a return value to use in the case of the particular constructor.

Algebraic classes

Type polymorphism

Last modified 3yr ago

Copy link

Contents

Object construction

Pattern matching

Case expression