Fun With Functions Block Scope { let a; { let

04

Function Scope function green() {
let a;
function yellow() {
let b;
… a …
… b …
}
… a …
} a

05

Closure function green() {
let a;
function yellow() {
let b;
… a …
… b …
}
… a …
} a b

06

Inner survives the outer function green() {
let a;
return function yellow() {
let b;
… a …
… b …
};
… a …
}

07

Write an identity function that takes an argument and returns that argument. identity(3) // 3

08

function identity(x) {
return x;
}

const identity = function identity(x) {
return x;
};

09

https://www.crockford.com/pp/fun.html
<!DOCTYPE html><html>
<head><meta charset="UTF-8"></head>
<body><script src="functions.js">
</script></body></html>

https://www.crockford.com/pp/functions.js
function identity(x) {
return x;
}
console.log("identity", 3, identity(3));

10

The Rules If you have a question, you must ask it.
I won’t debug your stuff.
If you need more time, let me know.

11

Quiz

12

What is x? function funky(o) {
o = null;
}
let x = [];
funky(x);
console.log(x); A.null
B.[]
C.undefined
D.throw

13

What is x? function funky(o) {
o = null;
}
let x = [];
funky(x);
console.log(x); A.null
B.[]
C.undefined
D.throw

14

function funky(o) {
o = null;
}
let x = [];
funky(x);
console.log(x); global [ ]

15

function funky(o) {
o = null;
}
let x = [];
funky(x);
console.log(x); global [ ] funky

16

function funky(o) {
o = null;
}
let x = [];
funky(x);
console.log(x); global [ ] funky

17

What is x? function swap(a, b) {
let temp = a;
a = b;
b = temp;
}
let x = 1;
let y = 2;
swap(x, y);
console.log(x); A.1
B.2
C.undefined
D.throw

18

What is x? function swap(a, b) {
let temp = a;
a = b;
b = temp;
}
let x = 1;
let y = 2;
swap(x, y);
console.log(x); A.1
B.2
C.undefined
D.throw

19

function swap(a, b) {
let temp = a;
a = b;
b = temp;
}
let x = 1;
let y = 2;
swap(x, y);
console.log(x); global 1 2

20

function swap(a, b) {
let temp = a;
a = b;
b = temp;
}
let x = 1;
let y = 2;
swap(x, y);
console.log(x); global 1 2 swap

21

function swap(a, b) {
let temp = a;
a = b;
b = temp;
}
let x = 1;
let y = 2;
swap(x, y);
console.log(x); global 1 2 swap

22

Write three binary functions, add , sub, and mul, that take two numbers and return their sum, difference, and product. add(3, 4) // 7
sub(3, 4) // -1
mul(3, 4) // 12

23

function add(first, second) {
return first + second;
}

function sub(first, second) {
return first - second;
}

function mul(first, second) {
return first * second;
}

24

Write a function identityf that takes an argument and returns a function that returns that argument. const unity = identityf(1);
unity() // 1

25

function identityf(x) {
return function () {
return x;
};
}

26

Write a function addf that adds from two invocations. addf(3)(4) // 7

27

function addf(first) {
return function (second) {
return first + second;
};
}

28

Write a function curry that takes a binary function and an argument, and returns a function that can take a second argument. let add3 = curry(add, 3);
add3(4) // 7

curry(mul, 5)(6) // 30

29

function curry(binary, first) {
return function (second) {
return binary(first, second);
};
}

30

function curry(binary, first) {
return function (second) {
return binary(first, second);
};
}

function curry(func, first) {
return liftf(func)(first);
} currying

schönfinkelisation

31

32

33

Write a function curryr that takes a binary function and a second argument, and returns a function that can take a first argument. let dec = curryr(sub, 1);
dec(7) // 6

34

function curryr(binary, second) {
return function (first) {
return binary(first, second);
};
}

35

Write a function liftf that takes a binary function, and makes it callable with two invocations. let addf = liftf(add);
addf(3)(4) // 7
liftf(mul)(5)(6) // 30

36

37

38

Without writing any new functions, show four ways to create the inc function. let inc = _ _ _ ;
inc(5) // 6
inc(inc(5)) // 7

39

1. inc = addf(1);

2. inc = curry(add, 1);

3. inc = curryr(add, 1);

4. inc = liftf(add)(1);

40

Write a function twice that takes a binary function and returns a unary function that passes its argument to the binary function twice. add(11, 11) // 22
let double = twice(add);
double(11) // 22
let square = twice(mul);
square(11) // 121

41

function twice(binary) {
return function (a) {
return binary(a, a);
};
}

42

Write reverse, a function that reverses the arguments of a binary function. let bus = reverse(sub);
bus(3, 2) // -1

43

function reverse(binary) {
return function (first, second) {
return binary(second, first);
};
}

function reverse(any) {
return function (...args) {
return any(...args.reverse());
};
}

44

Write a function composeu that takes two unary functions and returns a unary function that calls them both. composeu(double, square)(5) // 100

45

function composeu(f, g) {
return function (a) {
return g(f(a));
};
}

46

function composeu(...functions) {
return function (value) {
return functions.forEach(
function (func) {
value = func(value);
}
);
return value;
};
}

47

Write a function composeb that takes two binary functions and returns a function that calls them both. composeb(add, mul)(2, 3, 7) // 35

48

function composeb(f, g) {
return function (a, b, c) {
return g(f(a, b), c);
};
}

49

Write a limit function that allows a function to be called a limited number of times. let add_ltd = limit(add, 1);
add_ltd(3, 4) // 7
add_ltd(3, 5) // undefined

50

function limit(func, count) {
return function (...args) {
if (count >= 1) {
count -= 1;
return func(...args);
}
return undefined;
};
}

51

Generators Generator factory:
A function that returns a generator function.

Generator function:
A function that returns a series of values.

52

Write a from factory that produces a generator that will produce a series of values. let index = from(0);
index() // 0
index() // 1
index() // 2

53

function from(start) {
return function from_generator() {
let next = start;
start += 1;
return next;
};
}

54

Write a to factory that takes a generator and an end value, and returns a generator that will produce numbers up to but not including that limit. let index = to(from(2), 4);
index() // 2
index() // 3
index() // undefined

55

function to(gen, end) {
return function to_generator() {
let value = gen();
if (value < end) {
return value;
}
};
}

56

Write a fromTo factory that produces a generator that will produce values in a range. let index = fromTo(0, 3);
index() // 0
index() // 1
index() // 2
index() // undefined

57

function fromTo(start, end) {
return to(from(start), end);
}

58

Write an element factory that takes an array and a generator and returns a generator that will produce elements from the array. let ele = element(
["a", "b", "c", "d"],
fromTo(1, 3)
);
ele() // "b"
ele() // "c"
ele() // undefined

59

function element(array, gen) {
return function element_generator() {
let value = gen();
if (value !== undefined) {
return array[value];
}
};
}

60

Modify the element factory so that the generator argument is optional. If a generator is not provided, then each of the elements of the array will be produced. let ele = element(["a", "b", "c", "d"]);
ele() // "a"
ele() // "b"
ele() // "c"
ele() // "d"
ele() // undefined

61

function element(
array,
gen = fromTo(0, array.length)
) {
return function element_generator() {
let value = gen();
if (value !== undefined) {
return array[value];
}
};
}

62

Write a collect factory that takes a generator and an array and produces a generator that will collect the results in the array. let array = [];
let col = collect(fromTo(0, 2), array);
col() // 0
col() // 1
col() // undefined
array // [0, 1]

63

function collect(gen, array) {
return function collect_generator() {
let value = gen();
if (value !== undefined) {
array.push(value);
}
return value;
};
}

64

Write a filter factory that takes a generator and a predicate and produces a generator that produces only the values approved by the predicate. let fil = filter(
fromTo(0, 5),
function divisible_by_3(value) {
return (value % 3) === 0;
}
);
fil() // 0
fil() // 3
fil() // undefined

65

function filter(gen, predicate) {
return function filter_generator() {
let value;
do {
value = gen();
} while (
value !== undefined
&& !predicate(value)
);
return value;
};
}

66

function filter(gen, predicate) {
return function filter_generator() {
let value = gen();
if (
value === undefined
|| predicate(value)
) {
return value;
}
return filter_generator();
};
}

67

Write a concat factory that takes two generators and produces a generator that combines the sequences. let con = concat(fromTo(0, 3), fromTo(0,2));
con() // 0
con() // 1
con() // 2
con() // 0
con() // 1
con() // undefined

68

function concat(gen1, gen2) {
let gen = gen1;
return function concat_generator() {
let value = gen();
if (value !== undefined) {
return value;
}
gen = gen2;
return gen();
};
}

69

70

Write a repeat function that takes a generator and calls it until it returns undefined. let array = [];
repeat(collect(fromTo(0, 4), array));
log(array); // 0, 1, 2, 3

71

function repeat(gen) {
let value;
do {
value = gen();
} while (value !== undefined);
}

function repeat(func) {
if (func() !== undefined) {
return repeat(func);
}
}

72

function repeat(gen) {
let value;
do {
value = gen();
} while (value !== undefined);
}

function repeat(gen) {
if (gen() !== undefined) {
return repeat(gen);
}
}

73

Write a map function that takes an array and a unary function, and returns an array containing the result of passing each element to the unary function. Use the repeat function. map([2, 1, 0], inc) // [3, 2, 1]

74

75

Write a reduce function that takes an array and a binary function, and returns a single value. Use the repeat function. reduce([], add) // undefined
reduce([2], add) // 2
reduce([2, 1, 0], add) // 3

76

77

Make a gensymf factory that makes a unique symbol generator. let geng = gensymf("G");
let genh = gensymf("H");
geng() // "G1"
genh() // "H1"
geng() // "G2"
genh() // "H2"

78

function gensymf(prefix) {
let gen = from(1);
return function gensym_generator() {
return prefix + gen();
};
}

79

Write a gensymff factory factory that takes a factory function and a seed and returns a gensymf. let gensymf = gensymff(from, 1);
let geng = gensymf("G");
let genh = gensymf("H");
geng() // "G1"
genh() // "H1"
geng() // "G2"
genh() // "H2"

80

81

82

Make a fibonaccif factory that returns a generator that will produce the fibonacci sequence. let fib = fibonaccif(0, 1);
fib() // 0
fib() // 1
fib() // 1
fib() // 2
fib() // 3
fib() // 5

83

function fibonaccif(a, b) {
let i = 0;
return function () {
let next;
if (i === 0) {
i = 1;
return a;
}
if (i == 1) {
i = 2;
return b;
}
next = a + b;
a = b;
b = next;
return next;
};
}

84

function fibonaccif(a, b) {
return function () {
let next = a;
a = b;
b += next;
return next;
};
}

85

const single = composeu(identityf, curryr(limit, 1));

function fibonaccif(a, b) {
return concat(
concat(
single(a),
single(b)
),
function fibonacci() {
let next = a + b;
a = b;
b = next;
return next;
}
);
}

86

function fibonaccif(a, b) {
return concat(
element([a, b]),
function fibonacci() {
let next = a + b;
a = b;
b = next;
return next;
}
);
}

87

Write a counter constructor that returns an object containing two functions that implement an up/down counter, hiding the counter. let object = counter(10);
let up = object.up;
let down = object.down;
up() // 11
down() // 10
down() // 9
up() // 10

88

function counter(value) {
return {
up: function () {
value += 1;
return value;
},
down: function () {
value -= 1;
return value;
}
};
}

89

Make a revocable constructor that takes a function, and returns an object containing an invoke method that can invoke the function, and a revoke method that disables the invoke method. let rev = revocable(add);
let add_rev = rev.invoke;
add_rev(3, 4); // 7
rev.revoke();
add_rev(5, 7); // undefined

90

function revocable(any) {
return {
invoke: function (...args) {
if (any !== undefined) {
return any(...args);
}
},
revoke: function () {
any = undefined;
}
};
}

91

Write a function num that takes a value and an optional source string and returns them in an object. JSON.stringify(num(1))
// {"value": 1, "source": "1"}
JSON.stringify(num(Math.PI, "pi"))
// {"value": 3.14159…, "source": "pi"}

92

https://www.crockford.com/pp/num.js

function num(value, source) {
return {
value,
source: (
typeof source === "string"
? source
: String(value)
)
};
}

93

Write a function addnum that adds two num objects and returns an num object. JSON.stringify(addnum(num(3), num(4)))
// {"value": 7, "source": "(3+4)"}
JSON.stringify(addnum(num(1), num(Math.PI, "pi")))
// {"value": 4.14159…, "source": "(1+pi)"}

94

function addnum(a, b) {
return num(
a.value + b.value,
"(" + a.source + "+" + b.source + ")"
);
}

95

Write a function lifnutm that takes a binary function and a string and returns a function that acts on num objects. let addm = liftnum(add, "+");
JSON.stringify(addm(num(3), num(4)))
// {"value": 7, "source": "(3+4)"}
JSON.stringify(liftnum(mul, "*")(num(3), num(4)))
// {"value": 12, "source": "(3*4)"}

96

function liftnum(binary, op) {
return function (a, b) {
return num(
binary(a.value, b.value),
"(" + a.source + op + b.source + ")"
);
};
}

97

Modify function liftnum so that the functions it produces can accept arguments that are either numbers or m objects. let addnum = liftnum(add, "+");
JSON.stringify(addnum(3, 4))
// {"value": 7, "source": "(3+4)"}

98

99

Write a function exp that evaluates simple array expressions. let sae = [mul, 5, 11];
exp(sae) // 55
exp(42) // 42

100

function exp(value) {
return (
Array.isArray(value)
? value[0](value[1], value[2])
: value
);
}

101

Modify exp to evaluate nested array expressions. let nae = [
Math.sqrt,
[
add,
[square, 3],
[square, 4]
]
];
exp(nae) // 5

102

function exp(value) {
return (
Array.isArray(value)
? value[0](
exp(value[1]),
exp(value[2])
)
: value
);
}

// recursion: a function calls itself

103

Write a function addg that adds from many invocations, until it sees an empty invocation. addg() // undefined
addg(2)() // 2
addg(2)(7)() // 9
addg(3)(0)(4)() // 7
addg(1)(2)(4)(8)() // 15

104

105

Write a function liftg that will take a binary function and apply it to many invocations. liftg(mul)() // undefined
liftg(mul)(3)() // 3
liftg(mul)(3)(0)(4)() // 0
liftg(mul)(1)(2)(4)(8)() // 64

106

107

Write a function arrayg that will build an array from many invocations. arrayg() // []
arrayg(3)() // [3]
arrayg(3)(4)(5)() // [3, 4, 5]

108

function arrayg(first) {
let array = [];
function more(next) {
if (next === undefined) {
return array;
}
array.push(next);
return more;
}
return more(first);
}

109

function arrayg(first) {
if (first === undefined) {
return [];
}
return liftg(
function (array, value) {
array.push(value);
return array;
}
)([first]);
}

110

Make an objectify factory that takes an array of property names and returns a constructor that takes values and returns an object. let make = objectify("date", "marry", "kill");
JSON.stringify(make("butterfly", "unicorn", "monster"))
// {
// "date": "butterfly",
// "marry": "unicorn",
// "kill" : "monster"
// }

111

112

Make a join factory that takes a function and generators that provide arguments to the function. let fo = join(
objectify("number", "fibonacci"),
from(0),
fibonaccif(4, 5)
);
fo() // {"number": 0, "fibonacci": 4}
fo() // {"number": 1, "fibonacci": 5}
fo() // {"number": 2, "fibonacci": 9}

113

function join(func, ...gens) {
return function join_generator() {
return func(...gens.map(function (gen) {
return gen();
}));
};
}

114

Make a continuize factory that takes a function, and returns a function that takes a callback and an argument. let sqrtc = continuize(Math.sqrt);
sqrtc(console.log, 81);

115

function continuize(any) {
return function (continuation, ...args) {
return continuation(any(...args));
};
}

116

117

Make a vector constructor with methods get, store, and append, such that an attacker cannot get access to the private array. myvector = vector();
myvector.append(7);
myvector.store(1, 8);
myvector.get(0) // 7
myvector.get(1) // 8

118

function vector() {
const array = [];

return {
get: function get(i) {
return array[i];
},
store: function store(i, v) {
array[i] = v;
},
append: function append(v) {
array.push(v);
}
};
}

119

120

function vector() {
const array = [];

return {
get: function (i) {
return array[i];
},
store: function store(i, v) {
array[Number(i)] = v;
},
append: function (v) {
array[array.length] = v;
}
};
}

121

Make a function that makes a publish/subscribe object. It will reliably deliver all publications to all subscribers in the right order. my_pubsub = pubsub();
my_pubsub.subscribe(log);
my_pubsub.publish("It works!");
// log("It works!")

122

123

124

125

126

127

128

129

130

Fun With Functions Block Scope { let a; { let

Related Topics

Download this presentation From Below

Presentation Transcript

Fun With Functions Block Scope { let a; { let

Related Topics

Share

Embed code

Download this presentation From Below

Presentation Transcript