Millionways

Agenda
[Recursion, Corecursion, Transducers, Monoids, F-Algebras]

for (i = 0; i < xs.length; i++) {
xs[i] += 1;
}

var sum = function(xs) {
if(xs.length === 0) return 0;
return first(xs) + sum(rest(xs));
}

}
Base Case
Action
Recursion

var reverse = function(xs) {
if(xs.length === 0) return [];
return reverse(rest(xs)).concat(first(xs));
}

if(xs.length === 0) return [];
return reverse(rest(xs)).concat(first(xs));
}
Base Case
Action
Recursion

}
sum([1,2,3])
// 1 + sum([2,3])
// 1 + (2 + sum([3]))
// 1 + (2 + (3 + sum([])))
// 1 + (2 + (3 + 0))
// 1 + (2 + 3)
// 1 + 5
//=> 6

}
RangeError: Maximum call stack size exceeded

}
var sum = function(list) {
function go(acc, xs) {
if(xs.length === 0) return acc;
return go(acc+first(xs), rest(xs));
}
return go(0, list)
}

var reduce = function(f, acc, xs) {
return reduce(f, f(acc, first(xs)), rest(xs));
}

var sum = function(xs){
return reduce((acc, x) => x + acc, 0, xs)
}
return reduce((acc, x) => [x].concat(acc), [], xs)
}

var map = function(f, xs) {
return reduce((acc, x) => acc.concat(f(x)), [], xs)
}
var filter = function(f, xs) {
return reduce((acc, x) => f(x) ? acc.concat(x) : acc, [], xs)
}

any
all
size
max
min
sortBy
find
groupBy
first
last
take
drop
etc…

Any loop can be captured with a fold!

var para = function(f, acc, xs) {
return para(f, f(acc, first(xs), xs), rest(xs));
}

Agenda
[Corecursion, Transducers, Monoids, F-Algebras]
Recursion

var unfold = function(f, seed) {
function go(f, seed, acc) {
var res = f(seed);
return res ? go(f, res[1], acc.concat([res[0]])) : acc;
}
return go(f, seed, [])
}

unfold(x => if(x < 26) [String.fromCharCode(x+65), x+1], 0);
//=> [A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z]

var range = function(i, count) {
return unfold(x => if(x <= count) [x, x+1], i);
}
range(5,10)
//=> [ 5, 6, 7, 8, 9, 10 ]

var tree = Node(Node(Leaf(2), 1, Leaf(3)), 0, Leaf(4))
fold((acc, x) => acc + x, 0, tree)
//=> 10
var clicks = $("#red-button").asEventStream("click")
fold((acc, el) => acc.append(el.id), $("#clicklog"), clicks)
//=> <div id=“clicklog”/>
var us = {
“391": "keith@suburban",
“52": “kaseem@funny.net"
}
fold((acc, addr) => acc.cc(addr), Email.create(), us)
//=> Email

Cons(3, Cons(4, Cons(5, Nil)));
tail3 tail4 tail5 Nil
Linked List

var Nil = {}
var _Cons = function(h, tl) {
this.head = h;
this.tail = tl;
};
var Cons = function(h, tl) { return new _Cons(h, tl) }
var lst = Cons(3, Cons(4, Cons(5, Nil)));

1
Node(Node(Leaf(2), 1, Leaf(3)), 0, Leaf(4))
2 3
64
5
7
Tree

Agenda
[Transducers, Monoids, F-Algebras]
Recursion
Corecursion

return reduce((acc, x) => concat(acc, f(x)), [], xs)
}

return reduce((acc, x) => concat(acc, f(x)), [], xs)
}
Accumulation
Transformation Iteration

var mapper = function(f) {
return (acc, x) => concat(acc, f(x))
}
reduce(mapper(x => x + 1), [], [1,2,3])
//=> [2,3,4]

var mapper = function(f, cnct) {
return (acc, x) => cnct(acc, f(x))
}
reduce(mapper(x => x + 1, concat), [], [1,2,3])
//=> [2,3,4]

var filterer = function(f, cnct) {
return (acc, x) => f(x) ? cnct(acc, x) : acc
}
reduce(filterer(x => x > 1, concat), [], [1,2,3])
//=> [2,3]

var copy = function(xs) {
return reduce(concat, [], xs)
}

filterer(x => x > 1, mapper(x => x + 1, concat))
//=> (acc, x) => x > 1 ? concat(acc, f(x)) : acc

reduce(filterer(x => x > 1,
mapper(x => x + 1, concat)),
[], [1,2,3])
//=> [3,4]

mapper(x => x + 1, append)),
Nil, Cons(1, Cons(2, Cons(3, Nil))))
//=> [3,4]

mapper(x => x + 1, insert)),
Empty, Node(Node(Leaf(2), 1, Leaf(3)), 0, Leaf(4)))
//=> [3,4]

Iteration
Transformation
Accumulation

Agenda
[Monoids, F-Algebras]
Recursion
Corecursion
Transducers

// left identity
concat([], xs) == xs
// right identity
concat(xs, []) == xs
// associativity
concat(concat(xs, ys), zs) == concat(xs, concat(ys, zs))

return reduce((acc, x) => acc + x, 0, xs)
}

var _Sum = function(x) { this.val = x }
var Sum = function(x){ return new _Sum(x) }

_Sum.prototype.concat = function(y){
return Sum(this.val + y.val)
}
_Sum.prototype.empty = function(){ return Sum(0) }
return reduce((acc, x) => acc + x, 0, xs)
}

fold([Sum(1), Sum(2), Sum(3), Sum(4)])
//=> Sum(10)
_Sum.prototype.concat = function(y){
return Sum(this.val + y.val)
}
_Sum.prototype.empty = function(){ return Sum(0) }

fold([Product(1),Product(2),Product(3),Product(4)])
//=> Product(24)
_Product.prototype.concat = function(y){
return Product(this.val * y.val)
}
_Product.prototype.empty = function(){ return Product(1) }

fold([Max(11),Max(16),Max(3),Max(9)])
//=> Max(16)
_Max.prototype.concat = function(y){
return Max(this.val > y.val ? this.val : y.val)
}
_Max.prototype.empty = function(){ return Max(-Infinity) }

_All.prototype.concat = function(y){
return Any(this.val && y.val)
}
_All.prototype.empty = function(){ return All(true) }
fold([All(false), All(false), All(true), All(false)])
//=> All(false)

_Any.prototype.concat = function(y){
return Any(this.val || y.val)
}
_Any.prototype.empty = function(){ return Any(false) }
fold([Any(false), Any(false), Any(true), Any(false)])
//=> Any(true)

any
all
max
min
and
or
product
sum
find
contains
concat
toList

var foldMap = function(f,xs) {
return compose(fold, map(f))(xs);
}
var sum = function(xs){ return foldMap(Sum, xs).val }
var max = function(xs){ return foldMap(Max, xs).val }
var any = function(xs){ return foldMap(Any, xs).val }

var tree = Node(Node(Leaf(2), 1, Leaf(3)), 2, Leaf(4))
sum(tree)
//=> 12
product(tree)
//=> 38
max(tree)
//=> 4

var lst = Cons(true, Cons(false, Cons(true, Nil)))
any(lst)
//=> true
all(lst)
//=> false

[Sum(a)] -> Sum(a)
[Product(a)] -> Product(a)
[Max(a)] -> Max(a)

Agenda
[F-Algebras]
Recursion
Corecursion
Transducers
Monoids

var cata = function(f, xs) {
return f(xs.map(ys => cata(f,ys)))
}

Nil.map = function(f) { return Nil; }
_Cons.prototype.map = function(f) {
return Cons(this.head, f(this.tail))
}

var sum = function(x) {
return (x === Nil) ? 0 : x.head + x.tail
}
cata(sum, lst);
//=> 9

}
cata(sum, lst);
//=> 9
Algebra

}
cata(sum, lst);
// Nil
// Cons(4, 0)
// Cons(3, 4)
// Cons(2, 7)
//=> 9

map(x => x + 1, Cons(2, Cons(3, Cons(4, Nil))))
//=> Cons(3, Cons(4, Cons(5, Nil)))
return cata(x => (x == Nil) ? Nil : Cons(f(x.head), x.tail), xs)
}

Empty.map = function(f) { return Empty }
_Leaf.prototype.map = function(f) {
return Leaf(this.x)
}
_Node.prototype.map = function(f) {
return Node(f(this.left), this.x, f(this.right))
}

cata(t =>
switch (t.constructor) {
case _Node: return t.left + t.x + t.right;
case _Leaf: return t.x;
default: 0;
}, tr)
//=> 10
var tr = Node(Node(Leaf(2), 1, Leaf(3)), 0, Leaf(4))

var ana = function(g, a) {
return g(a).map(x => ana(g,x))
}

var arrToList = function(xs) {
return xs.length === 0 ? Nil : Cons(first(xs), rest(xs))
}
ana(arrToList, [1,2,3,4,5])
//=> Cons(1, Cons(2, Cons(3, Cons(4, Cons(5, Nil)))))
CoAlgebra

var arrToList = function(xs) {
return xs.length === 0 ? Nil : Cons(first(xs), rest(xs))
}
ana(arrToList, [1,2,3,4,5])
//=> Cons(1, Cons(2, Cons(3, Cons(4, Cons(5, Nil)))))

var makeAlphabet = function(x) {
if(x > 25) return Nil;
return Cons(String.fromCharCode(x+65), x+1);
}
ana(makeAlphabet, 0)
//=> Cons(A, Cons(B, Cons(C, Cons(D, Cons(E, Cons(F, Cons(G, Cons(H

var range = function(acc, count) {
return ana(x => (x >= count) ? Nil : Cons(x, x+1), acc)
}
range(2, 10)
//=> Cons(2, Cons(3, Cons(4, Cons(5, Cons(6, Cons(7, Cons(8,
Cons(9, Nil))))))))

Mul(Add(Const(2), Const(3)), Const(4))

var _Const = function(val) { this.val = val }
var Const = function(x) { return new _Const(x) }
var _Add = function(x, y) {
this.x = x;
this.y = y;
}
var Add = function(x, y) { return new _Add(x, y) }
var _Mul = function(x, y) {
this.x = x
this.y = y
}
var Mul = function(x, y) { return new _Mul(x, y) }

_Const.prototype.map = function(f) { return this }
_Add.prototype.map = function(f) {
return Add(f(this.x), f(this.y))
}
_Mul.prototype.map = function(f) {
return Mul(f(this.x), f(this.y))
}

var interpret = function(a) {
switch(a.constructor) {
case _Mul: return a.x * a.y;
case _Add: return a.x + a.y;
case _Const: return a.val;
}
}
var program = Mul(Add(Const(2), Const(3)), Const(4))
cata(interpret, program);
//=> 20

_Concat.prototype.map = function(f) {
return Concat(this.val, f(this.next))
}
_Replace.prototype.map = function(f) {
return Replace(this.val, this.x, f(this.next))
}
_Input.prototype.map = function(f) {
return Input(this.val)
}

var interpret = function(t) {
case _Concat: return t.next.concat(t.val);
case _Replace: return t.next.replace(t.val, t.x);
case _Input: return t.val;
}
}
var prog = Concat("world", Replace("h", "m", Input(“hello")))
cata(interpret, prog)
//=> melloworld

var interpret1 = function(t) {
case _Concat:
return "concatting “+t.val+" after "+t.next;
case _Replace:
return "replacing "+t.val+" with "+t.x+" on "+t.next;
case _Input:
return t.val;
}
}
var prog = Concat("world", Replace("h", "m", Input(“hello")))
cata(interpret1, prog)
//=> concatting world after replacing h with m on hello

Agenda
Recursion
Corecursion
Transducers
Monoids
F-Alegbras

THanks!
@drboolean
https://github.com/DrBoolean/RecursionTalk

Millionways

More Related Content

Millionways