-
Notifications
You must be signed in to change notification settings - Fork 0
/
04_Lambda_Functions.olly
116 lines (95 loc) · 3.1 KB
/
04_Lambda_Functions.olly
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
##############################################################
Functions in the Oliver language are nothing more than
lambda expressions, anonymous functions, defined by
the combination of two expressions, the arguments and
the body. An example:
func(x): x << ;
The 'func' keyword identifies the expression as a
lambda expression. '(x)' is the argument expression.
': x << ;' is the body expression. Lambda functions
perform abstraction by the substitution of the value
of their arguments within the body of the function.
Going forward we will refer to all lambda expressions
simply as function expressions.
##############################################################
#! NO_EXCEPT = false
let f = func(x): "x = " << x << ;
f '42'
endl
# This function is almost identical to the identity
# function. All it does is substitute '42' for 'x'
# then emitting the value of '42'.
##############################################################
For convience, function expression can be defined with
the 'def' keyword.
##############################################################
def f(x): "x = " << x << endl;
f '2.25'
endl
##############################################################
Function expressions, used in conjunction with logical
operations can be used to manipulate data. The function
'f' below simply counts up to or down to '10'.
##############################################################
let x = '0'
def f(y):
if (y < '10'):
let y = (y + '1')
"y = " << y << endl
f y
;
elif (y > '10'):
let y = (y - '1')
"y = " << y << endl
f y
;
;
"(f x):" << endl
(f x) endl
endl
##########################################################
Function expressions, have their own enclosure. That
is any variable bound as an argument is difrent than
any other variable with the same name. Bellow we
redifine 'f' so the name of it argument is the same
as the global variable of 'x'.
##########################################################
def f(x):
if (x < '10'):
let x = (x + '1')
"x = " << x << endl
f x
;
elif (x > '10'):
let x = (x - '1')
"x = " << x << endl
f x
;
;
"(f x):" << endl
(f x) endl
"global x still is = " << x << endl
endl
##########################################################
Function expression closures are indipendant of each
other. Below is an example of the reuse of the 'n'
identifier as a variable and a funtion.
##########################################################
def adder(x):
def n():
def n(y):x + y;
-n
;
n
;
let f = (adder '42')
let x = '8'
"x = " << x << endl
"f = " << -f << endl
"(f x) = " << (f x) << endl
##########################################################
Notice above we used a unary negation '-' operator.
Unary negation sbinds the function enclosure to the
previous closure. We will go into more detail in
the next section.
##########################################################