9.51 MappingPackage1
Function are objects of type Mapping. In this section we
demonstrate some library operations from the packages
MappingPackage1, MappingPackage2, and MappingPackage3
that manipulate and create functions. Some terminology: a
nullary function takes no arguments, a unary function takes
one argument, and a binary function takes two arguments.
We begin by creating an example function that raises a
rational number to an integer exponent.
power(q: FRAC INT, n: INT): FRAC INT == q**n
Function declaration power : (Fraction Integer,Integer) ->
Fraction Integer has been added to workspace.
Void
Compiling function power with type (Fraction Integer,Integer) ->
Fraction Integer
Type: Fraction Integer
The twisttwistMappingPackage3 operation transposes the
arguments of a binary function. Here rewop(a, b) is
power(b, a).
Type: ((Integer,Fraction Integer) -> Fraction Integer)
This is
Type: Fraction Integer
Now we define square in terms of power.
square: FRAC INT -> FRAC INT
Void
The curryRightcurryRightMappingPackage3 operation creates a
unary function from a binary one by providing a constant argument on
the right.
square:= curryRight(power, 2)
Type: (Fraction Integer -> Fraction Integer)
Likewise, the curryLeftcurryLeftMappingPackage3 operation
provides a constant argument on the left.
Type: Fraction Integer
The constantRightconstantRightMappingPackage3 operation creates
(in a trivial way) a binary function from a unary one:
constantRight(f) is the function g such that
g(a,b)= f(a).
squirrel:= constantRight(square)$MAPPKG3(FRAC INT,FRAC INT,FRAC INT)
Type: ((Fraction Integer,Fraction Integer) -> Fraction Integer)
Likewise, constantLeft(f) is the function g such that
g(a,b)= f(b).
Type: Fraction Integer
The currycurryMappingPackage2 operation makes a unary
function nullary.
sixteen := curry(square, 4/1)
Type: (() -> Fraction Integer)
Type: Fraction Integer
The * operation constructs composed
functions.
Type: (Fraction Integer -> Fraction Integer)
Type: Fraction Integer
Use the ** operation to create functions
that are n-fold iterations of other functions.
sc(x: FRAC INT): FRAC INT == x + 1
Function declaration sc : Fraction Integer ->
Fraction Integer has been added to workspace.
Void
This is a list of Mapping objects.
incfns := [sc**i for i in 0..10]
|
|
Type: List (Fraction Integer -> Fraction Integer)
This is a list of applications of those functions.
|
|
Type: List Fraction Integer
Use the recurrecurMappingPackage1
operation for recursion:
g := recur f means g(n,x) == f(n,f(n-1,...f(1,x))).
times(n:NNI, i:INT):INT == n*i
Function declaration times : (NonNegativeInteger,Integer) ->
Integer has been added to workspace.
Void
Type: ((NonNegativeInteger,Integer) -> Integer)
This is a factorial function.
Type: (NonNegativeInteger -> Integer)
Type: PositiveInteger
Constructed functions can be used within other functions.
mto2ton(m, n) ==
raiser := square**n
raiser m
Void
This is
Compiling function mto2ton with type (PositiveInteger,
PositiveInteger) -> Fraction Integer
Type: Fraction Integer
Here shiftfib is a unary function that modifies its argument.
shiftfib(r: List INT) : INT ==
t := r.1
r.1 := r.2
r.2 := r.2 + t
t
Function declaration shiftfib : List Integer -> Integer
has been added to workspace.
Void
By currying over the argument we get a function with private state.
fibinit: List INT := [0, 1]
Type: List Integer
fibs := curry(shiftfib, fibinit)
Type: (() -> Integer)
|
|
Type: List Integer