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

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie The Shape of Functional Programming

Ähnlich wie The Shape of Functional Programming (18)

Mehr von Mike Fogus

Mehr von Mike Fogus (6)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

The Shape of Functional Programming

Hinweis der Redaktion