Functional Patterns for the non-mathematician

Functional Patterns
for the non-mathematician

// associative
add(add(1, 2), 4) == add(1, add(2, 4))
// commutative
add(4, 1) == add(1, 4)
// identity
add(n, 0) == n
// distributive
multiply(2, add(3,4)) == add(multiply(2, 3), multiply(2, 4))

var inc = new Increaser(4);
inc.increaseBy(2);
inc.value();
// 6

Interfaces
Properties/Laws
Polymorphic
Composable

var reverseCap = compose(capitalize, reverse)
reverseCap(“hello”)
//=> “Olleh”
Composition

var reverseCap = compose(capitalize, reverse)(“hello”)
//=> “Olleh”
Composition
“hello”“olleh”“Olleh”

compose(compose(f, g), h) == compose(f, compose(g, h))
Composition
(associativity)

compose(f, g, h)
Composition
(associativity)

var i = compose(g, h)
compose(f, i)
Composition
(associativity)

var getFromDb = compose(pluck('rows'), User.findAll)
var cleanUpData = compose(capitalize, pluck('name'))
var renderTemplate = TemplateEngine.render(‘users_table')
var makePage = compose(renderTemplate, map(cleanUpData), getFromDb)
makePage({limit: 20})

var getFromDb = compose(pluck('rows'), User.findAll)
var cleanUpData = compose(capitalize, pluck('name'))
var renderTemplate = TemplateEngine.render(‘users_table')
var makePage = compose(renderTemplate, map(cleanUpData), getFromDb)
Perfect world

function (property, x) {
return x[property];
}
Getters/Setters
function (property, value, x) {
x[property] = value;
return x;
}

Lenses
over(l, f, x)
view(l, x)
set(l, y, x)

var user = {id: 1, name: ‘Alicia'}
var L = makeLenses([‘name’])
view(L.name, user) // 'Alicia'
set(L.name, 'Ally', user) // {id: 1, name: 'Ally'}
over(L.name, toUpperCase, user) // {id: 1, name: 'ALICIA'}
Lenses

var user = {id: 1, name: {first: ‘doris’, last: ‘day’ }}
var L = makeLenses([‘name’, ‘first’])
var firstNameChar = compose(L.name, L.first, _1)
over(firstNameChar, toUpperCase, user)
//=> {id: 1, name: {first: ‘Doris’, last: ‘day’ }}
Lenses

view(l, set(l, b, a)) == b
set(l, view(l, a), a) == a
set(l, c, set(l, b, a)) == set(l, c, a)
Lens laws

if(x !== null && x !== undefined) {
return f(x)
}
Null checking

fmap(f, Maybe(x))
Null checking

var fmap = function(f, mappable) {
return mappable.map(f)
}
Null checking

fmap(function(x) { return x.toUpperCase() }, Maybe(‘hi’))
//=> Maybe(‘HI’)
fmap(function(x) { return toUpperCase(x); }, Maybe(null))
//=> Maybe(null)
Null checking

fmap(function(x) { return x.toUpperCase() }, Maybe(‘hi’))
//=> Maybe(‘HI’)
fmap(function(x) { return x.toUpperCase() }, Maybe(null))
//=> Maybe(null)
Null checking

compose(fmap(f), Maybe)
Null checking

var id = function(x) { return x; }
fmap(id, x) == id(x)
Fmap laws
(identity)

compose(fmap(f), fmap(g)) == fmap(compose(f, g))
Fmap laws
(composition)

return f(x)
} else {
throw ‘Some Error!’
}
Error Handling

Error Handling
fmap(f, Either(‘Some error’, x))

Either(‘need an int’, 3)
//=> Right(3)
fmap(function(x) { return x + 1; }, Either(‘need an int’, undefined))
//=> Left(‘need an int’)
Error Handling

Either(‘need an int’, 3)
//=> Right(3)
Either(‘need an int’, undefined))
Error Handling

fmap(function(x) { return x + 1; }, Right(2))
//=> Right(3)
fmap(function(x) { return x + 1; }, Either(‘need an int’, undefined))
Error Handling

fmap(function(x) { return x + 1; }, Right(2))
//=> Right(3)
fmap(function(x) { return x + 1; }, Left(‘need an int’))
Error Handling

compose(fmap(f), Either(‘error’))
Error Handling

f(x, function(y) {
return g(y);
});
Future values

Future values
fmap(f, Promise(x))

var p = new Promise();
fmap(function(x) { return log(reverse(x)) }, p)
//=> Promise()
p.resolve([1,2,3])
//=>[3, 2, 1]
Future values

Something that implements map
Functor

var y = f(x)
if(y !== null && y !== undefined) {
return g(y)
}
}
Nesting

f(x, function(y) {
return g(y, function(z) {
return h(z)
})
})
Nesting

compose(mjoin, fmap(f))
Nesting

var getField = compose(Maybe, document.querySelector)
var getValue = compose(Maybe, pluck(‘value’))
var greet = compose(fmap(fmap(concat(‘hello’))), fmap(getValue), getField)
greet(‘#name’)
//=> Maybe(Maybe(‘hello chris’))
var greet = compose(fmap(concat(‘hello’)), mjoin, fmap(getValue), getField)
greet(‘#name’)
//=> Maybe(‘hello chris’)
Nesting

compose(mjoin, fmap(g), mjoin, fmap(f))
Nesting
mcompose(g, f)

mcompose(mcompose(f, g), h) == mcompose(f, mcompose(g, h))
mcompose(f, M) == f
mcompose(M, f) == f
Monad laws

Multiple null args
var notNull = function(x) {
return x !== null && x !== undefined
}
if(notNull(x) && notNull(y)) {
return f(x, y)
}

Multiple Async fn’s
var y,z;
f(x, function(result) {
y = result;
if(z) {
return h(y, z)
})
})
g(x, function(result) {
z = result;
if(y) {
return h(y, z)
})
})

liftA2(f, A(x), A(y))
Multiple values

liftA3(f, A(x), A(y), A(z))
Multiple values

liftA2(add, Maybe(3), Maybe(4))
//=> Maybe(7)
liftA2(add, Maybe(null), Maybe(4))
//=> Maybe(null)
Multiple values

var tweets_p = Http.get(‘/twitter/tweets’)
var photos_p = Http.get(‘/flickr/photos’)
var makeCollage = _.curry(function (tweets, photos){})
liftA2(makeCollage, tweets_p, photos_p)
Multiple values

// identity
ap(A(id), m) == m
// composition
ap(ap(ap(A(compose), f), g), w) == ap(f, ap(g, w))
// homomorphism
ap(A(f), A(x)) == A(f(x))
// interchange
ap(u, A(x)) == ap(A(function(f) { return f(x); }), u)
Applicative laws

Accumulation
reduce(function(acc, x) {
return acc + x;
}, 0, [1,2,3])

Accumulation
return acc * x;
}, 1, [1,2,3])

Accumulation
return acc || x;
}, false, [false, false, true])

Accumulation
return acc && x;
}, true, [false, false, true])

Accumulation
return acc > x ? acc : x;
}, 0, [12, 5, 35])

Monoid
mappend(m, m)
mempty(m)
mconcat([m])

mconcat([Sum(1), Sum(2), Sum(3)])
//=> Sum(6)
Accumulation

mconcat([Product(1), Product(2), Product(3)])
//=> Product(6)
Accumulation

mconcat([Max(13), Max(2), Max(9)])
//=> Max(13)
Accumulation

mconcat([Any(false), Any(false), Any(true)])
//=> Any(true)
Accumulation

mconcat([All(false), All(false), All(true)])
//=> All(false)
Accumulation

compose(mconcat, map(M))
Accumulation

// left identity
mappend(mempty, x) == x
// right identity
mappend(x, mempty) == x
// associativity
mappend(mappend(x, y), z) == mappend(x, mappend(y, z))
Monoid laws

Combinators
function(x) {
return [f(x), g(x)]
}

Combinators
function(x, y) {
return [f(x), g(y)]
}

compose(f, g)
ampersand(f, g)
asterisk(f, g)
first(f)
second(f)
Arrows

first(reverse)([‘Stan’, ‘Lee']) // [‘natS’, ‘Lee’]
second(reverse)([‘Stan’, ‘Lee']) // [‘Stan’, ‘eeL’]
ampersand(reverse, toUpperCase)(‘Stan’) // [‘natS’, ‘STAN’]
asterisk(reverse, toUpperCase)([‘Stan’, ‘Lee']) // [‘natS’, ‘LEE’]
Arrows

A(id) == id
A(compose(f, g)) == A(compose(f, A(g)))
first(A(f)) == A(first(f))
first(compose(f, g)) == compose(first(f), first(g))
compose(first(f), A(pluck(0))) == compose(A(pluck(0)), f)
compose(first(f), A(asterisk(id, g)) == compose(A(asterisk(id, g)), first(f))
compose(first(first(f)), A(assoc) == compose(A(assoc), first(f))
Arrow laws

Thanks!
@drboolean
https://github.com/DrBoolean/patterns_talk

Functional Patterns for the non-mathematician

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (9)

Similar to Functional Patterns for the non-mathematician

Similar to Functional Patterns for the non-mathematician (20)

Recently uploaded

Recently uploaded (20)

Functional Patterns for the non-mathematician