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

λ -c alculus 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 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

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

Higher order function example //evaluate derivative of x 2 : 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 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, …)?

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 . x function identity ( x ) { return x ; } //Church numeral zero // λ f . λ x . x function 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 number function 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 number function 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 .

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 JavaScript function 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 Factorial function 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

Introduction to Functional Programming in JavaScript

Recommended

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to Introduction to Functional Programming in JavaScript (20)

Recently uploaded (20)

Introduction to Functional Programming in JavaScript