The Shape of Functional Programming

The Shape
of
Functional
Programming
Saturday, October 5, 13

@fogus
http://www.fogus.me
http://github.com/documentcloud/underscore-contrib

@fogus
“Functional
JavaScript”Lemonad
codd.js

A
program
written in an
object-oriented
style

Functional
programming
for the MEOW!

Pattern 1 - Map(ish)
var array = [0,1,2,3,4,5];
var transformed = [];

for (var i = 0; i < array.length; i++) {
transformed.push(array[i] + 100);
}

transformed;
//=> [100, 101, 102, 103, 104, 105]

Pattern 1 - Map(ish)
// Underscore

_.map(array, function(n) {
return n + 100;
});

// Lemonad

L.map(L.add(100), array);

Pattern 2 - Filter(ish)
var array = [0,1,2,3,4,5];
var keepers = [];

if (array[i] % 2 === 0) {
keepers.push(array[i]);
}
}

keepers;
//=> [101, 102, 103, 104, 105]

Pattern 2 - Filter(ish)
// Underscore

_.filter(array, function(n) {
if (n % 2 === 0) {
return true;
}
else {
return false;
}
});

// Lemonad

L.filter(L.isEven, array);

Pattern 3 - Reduce(ish)
var array = [0,1,2,3,4,5];
var sum = 0;

sum += array[i];
}

sum;
//=> 15

Pattern 3 - Reduce(ish)
// Underscore

_.reduce(array, function(acc, n) {
return acc + n;
}, 0);

// Lemonad

L.reduce(L.uncurry(L.add), 0, array);

APL
life←{↑1 ⍵∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂⍵}
0 1 0 0 1 0 0 1 0
0 1 0
0 1 0
0 1 0

Fun.js at a glance
• Simple data
• Many small functions
• Larger abstractions built via composition
• OO to supplement (no dogma)

Simple data

#
[1, 2, 3, 4, 5]

#“
{x: 0, y: 1}

{x: 0, y: 1}
#

Small functions

Disclaimer

#
Procedure

function logNth(array, index) {
console.log(array[index]);
}
logNth([‘a’, ‘b’, ‘c’], 1);
// (console) b
#

Purity

Ostrich Purity

#
Function
Kinda important

function nth(array, index) {
return array[index];
}
nth([‘a’, ‘b’, ‘c’], 1);
//=> ‘b’
#

id name age
555-55-5555 Moe 45
777-77-7777 Curly 47
0
1

var table = [
{id: ‘555-55-5555’,
name: ‘Moe’,
age: 45},
{id: ‘777-77-7777’,
name: ‘Curly’,
age: 47}
];

function cell(table, col, row){
return table[row][col];
}
cell(table, ‘name’, 0);
//=> ‘Moe’
cell(table, ‘age’, 0);
//=> 45
#“

Larger abstractions
built via composition

L
Clojure, Haskell, ML, Joy, _

Currying, partial
application, ﬁxation, oh
my!

#“
L.ﬁx

#
L.fix(cell, L._, ‘name’, L._);
‘name’

#
L.fix(cell, L._, ‘name’, L._);
var getName = L.fix(cell, L._, ‘name’, L._);
getName(table, 0);
//=> ‘Moe’
getName(table, 1);
//=> ‘Curly’
‘name’

#“
L.rot

#
L.rot(cell);
“

#“
L.partial

L.partial(L.rot(cell), ‘name’);
#‘name’

L.partial(L.rot(cell), ‘name’);
var getName = L.partial(L.rot(cell), ‘name’);
getName(0, table);
//=> ‘Moe’
getName(1, table);
//=> ‘Curly’
#‘name’

L.rcurry
“
Codd.col(table, ‘name’);
//=> [‘Moe’, ‘Curly’]

“
“
L.rcurry2(Codd.col);

“
L.rcurry2(Codd.col);
var valuesFor = L.rcurry2(Codd.col);
var allNames = valuesFor(‘name’);
allNames(table);
//=> [‘Moe’, ‘Curly’]

Compositions and
Pipelines

How to count
all of the values
in a column?

“
function countValues(table, tag) {
return L.len(Codd.col(table, tag));
}
countValues(table, ‘name’);
//=> 2
#

L.comp
return L.len(Codd.col(table, tag));
First thisThen this

“Codd.col
#
L.len

“
var countValues = L.comp(L.len, Codd.col);
countValues(table, ‘name’);
//=> 2
#

L.pipeline
L.pipeline(table, Codd.col(‘name’), L.len);
//=> 2
First this Then this

codd.js (demo)
Relational Algebra

Thanks
• The NationJS team
• O’Reilly
• Alan Dipert
• Paul Khuong
• The Underscore community
• The Clojure community

The Shape of Functional Programming

Recommandé

Recommandé

Contenu connexe

Similaire à The Shape of Functional Programming

Similaire à The Shape of Functional Programming (18)

Plus de Mike Fogus

Plus de Mike Fogus (6)

Dernier

Dernier (20)

The Shape of Functional Programming

Notes de l'éditeur