General Computer Science 320201 GenCS I & II Lecture ... - Kwarc

42CHAPTER 4. COMPUTING WITH FUNCTIONS OVER INDUCTIVELY DEFINED SETS
©: Michael Kohlhase 63
While the previous inputs to the interpreters do not change its state, declarations do: they bind
identifiers to values. In the first example, the identifier twovec to the type int * int, i.e. the
type of pairs of integers. Functions are declared by the fun keyword, which binds the identifier
behind it to a function object (which has a type; in our case the function type real -> real).
Note that in this example we annotated the formal parameter of the function declaration with a
type. This is always possible, and in this necessary, since the multiplication operator is overloaded
(has multiple types), and we have to give the system a hint, which type of the operator is actually
intended.
Programming in SML (Pattern Matching)
Component Selection: (very convenient)
- val unitvector = (1,1);
val unitvector = (1,1) : int * int
- val (x,y) = unitvector
val x = 1 : int
val y = 1 : int
Definition 99 anonymous variables (if we are not interested in one value)
- val (x,_) = unitvector;
val x = 1 :int
Example 100 We can define the selector function for pairs in SML as
- fun first (p) = let val (x,_) = p in x end;
val first = fn : ’a * ’b -> ’a
Note the type: SML supports universal types with type variables ’a, ’b,. . . .
first is a function that takes a pair of type ’a*’b as input and gives an object of type ’a
as output.
©: Michael Kohlhase 64
Another unusual but convenient feature realized in SML is the use of pattern matching. In
pattern matching we allow to use variables (previously unused identifiers) in declarations with the
understanding that the interpreter will bind them to the (unique) values that make the declaration
true. In our example the second input contains the variables x and y. Since we have bound the
identifier unitvector to the value (1,1), the only way to stay consistent with the state of the
interpreter is to bind both x and y to the value 1.
Note that with pattern matching we do not need explicit selector functions, i.e. functions that
select components from complex structures that clutter the namespaces of other functional languages.
In SML we do not need them, since we can always use pattern matching inside a let
expression. In fact this is considered better programming style in SML.
What’s next?
More SML constructs and general theory of functional programming.
©: Michael Kohlhase 65
One construct that plays a central role in functional programming is the data type of lists. SML
has a built-in type constructor for lists. We will use list functions to acquaint ourselves with the
essential notion of recursion.