introduction to functional programming in javascript

Functional Programming

Tommy “is awesome” Montgomery

2009-03-06

What is functional programming? Uses functions Lambda Calculus Very academic Kinda goofy

Elements of functional languages Recursion Functions (der) No state

Functional Languages Haskell Erlang F# OCaml Scheme Smalltalk

J K Mathematica XSLT LISP (kinda)

Fun Fact #1 Tommy was once a professional musician

λ-calculus Anonymous functions

JavaScript PHP 4.0.1 – PHP 5.2.x (kinda) PHP 5.3 (more kinda) C# 2.0 Java sucks, as usual

Unary Functions take one argument, and return one

value

Example

λ x . x + 2

Example

λ x . x + 2

input

Example

λ x . x + 2

input return value

Example

λ x . x + 2

input return value

f(x) = x + 2

Higher order functions Functions that take functions as arguments and return

functions Where the real power of functional programming lies

Higher order function example Mathematical derivative

xxdx

d22

Higher order function example

//f is a functionfunction derivative(f) { return function(x) { //approximation of derivative return (f(x + 0.00001) – f(x)) / 0.00001; }}

Higher order function example

//evaluate derivative of x2:var deriv_x_squared = derivative( function(x) { return x*x; });

alert(deriv_x_squared(3)); //alerts 6ish

Fun Fact #2 Tommy used to be a gangsta

Bound variables The λ operator binds

its variables to its scope

All other variables are “free”

Freedom

Bound variables

λ x . x + y

Bound variables

λ x . x + y bound variable bound variable free variable

Bound variables

λ x . x + y bound variable bound variable free variable

f(x) = x + y

Natural numbers Everything is a function, remember? How do we define the natural numbers in

functional programming (1, 2, 3, …)?

very painfully

Church numerals 0 ≡ λ f . λ x . x 1 ≡ λ f . λ x . f x 2 ≡ λ f . λ x . f (f x) 3 ≡ λ f . λ x . f (f (f x)) ...

Church numerals in JavaScript//identity function// λ x . xfunction identity(x) { return x;}

//Church numeral zero// λ f . λ x . xfunction zero(f) { return identity;}

Church numerals in JavaScript//successor function (succ(n) = n + 1)// λ n . λ f . f (n f x)function succ(n) { return function(f) { return function(x) { return f(n(f)(x)); } }}

Church numerals in JavaScript//gets a function representing//the nth church numberfunction getChurchNumber(n) { var ret = zero; for (var i = 0; i < n; i++) { ret = succ(ret); } return ret;}

Church numerals in JavaScript//gets the nth church numberfunction getNaturalNumber(n) { var value = 0; for (var i = 0; i < n; i++) { value += getChurchNumber(i)( function(x) { return x + 1; } )(0); } return value;}

Fun fact #3 Wombats are unfairly cute

Addition// λ m . λ n . λ f . n f (m f x)function add(m) { return function(n) { return function(f) { return function(x) { return n(f)(m(f)(x)); } } }}

Addition using successor// λ m . λ n . m succ n

function addWithSucc(m) {

return function(n) {

return m(succ)(n);

}

}

Holy crap http://uxul.wordpress.com/2009/03/02/generating-church-numbers-with-javascript/

Recursion Local variables are the devil! Also, a paradox In lambda calculus, you cannot define a

function that includes itself i.e. the definition of recursion

The Y Combinator Cool name Also known as “The Paradoxical Operator”

Recursion

To properly define recursion, a recursive function g must take as an argument a function f, which expands to g which takes an argument f.

Got that?

Recursion f = g(f) f is a fixed point of g Known as the Y-Combinator

The Y-Combinator

Y = λ g . (λ x . g (x x)) (λ x . g (x x))

The Y-Combinator in JavaScriptfunction Y(g) { return function(x) { return g( function(y) { return x(x)(y); } ); }( function(x) { return g( function(y) { return x(x)(y); } ); } );}

http://matt.might.net/articles/implementation-of-recursive-fixed-point-y-combinator-in-javascript-for-memoization/

Functional Factorial

Y factorial n

• Y : definition of Y-Combinator• factorial: functional definition of factorial• n : integer

Functional Factorialfunction factorial(f) { return function(n) {

return (n == 0) ? 1 : n * f(n – 1);

}

}

//call like so:

alert(Y(factorial)(5)); //alerts 120

What is happening? Recursive calls are abstracted to an inner

function, which is evaluated as a lambda function (which by very definition are not recursive, remember?)

Interesting, but not all that useful…

Other topics… Currying Mapping Reduction Substitution Elaboration on statelessness Imperative vs. Functional Performance

Questions…