Table of Contents
+-
+
- 1. Why? +
- 2. Concepts +
- 3. Further concepts +
- 4. First-class functions +
- 5. Higher-order functions +
- 6. Higher-order functions (cont.) +
- 7. Pure functions +
- 8. Recursion +
- 9. Partial application +
- 10. Partial application (cont.) +
- 11. Currying +
- 12. Easy Currying +
- 13. Practical Currying +
- 14. Functional composition +
- 15. Functional composition (cont.) +
- 16. pipe +
- 17. Point-free programming +
- 18. Further Resources +
1 Why?
++Imperative programming is concerned with how +
+ ++Functional programming is concerned with what +
+2 Concepts
+-
+
- First-class Functions +
- Higher-order Functions +
- Recursion +
- Pure functions +
- Currying & Partial Application +
3 Further concepts
+-
+
- Lazy Evaluation +
- Types & Data Structures +
- Category Theory +
4 First-class functions
+-
+
- Are values +
- Have no restriction on their use +
- Enable the use of callback functions in JavaScript +
+ +
+ +var fn = function () {
+ return 2
+}
+5 Higher-order functions
++Functions that operate on other functions are higher-order functions +
+ ++ +
+ +var succ = function (x) {
+ return x + 1
+}
+
+var arr = [1, 2, 3, 4]
+
+arr.map(succ)
+
+Here, Array.prototype.map is the higher-order function
+
6 Higher-order functions (cont.)
++Functions that return functions are also higher-order functions +
+ ++ +
+ +function adder (n) {
+ return function (x) {
+ return n + x
+ }
+}
+
+var add1 = adder(1)
+
+adder is a higher-order function
+
7 Pure functions
++Functions without side-effects +
+ +var succ = (x) => x + 1
+
+console.log(succ(succ(1)))
+
+// could be optimised away by a compiler, e.g.:
+
+console.log(3)
+8 Recursion
++Functions that call themselves +
+ +function fibonacci (n) {
+ switch (n) {
+ case 0:
+ case 1:
+ return 1
+ default:
+ return fibonacci(n - 1) + fibonacci(n - 2)
+ }
+}
+9 Partial application
+
+The infamous Function.prototype.bind in JavaScript
+
function add (x, y) {
+ return x + y
+}
+
+var add1 = add.bind(add, 1)
+
+add1(3) // = 4
+10 Partial application (cont.)
++After ES6 introduced arrow functions, partial application has become +more popular +
+ +var add = x => y => x + y
+11 Currying
++Related to partial application, but more implicit and general +
+ ++Translates 1 function of arity n to n functions of arity 1 +
+ +function volume (w, d, h) {
+ return w * d * h
+}
+
+var vol = curry(volume)
+vol(10)(20)(30)
+// is strictly equivalent to
+volume(10, 20, 30)
+12 Easy Currying
++In order to make currying (and partial application) easier to use, +move the most important argument to a function to the end: +
+ +var badMap = (arr, fn) => arr.map(fn)
+var goodMap = (fn, arr) => arr.map(fn)
+var curriedBadMap = curry(badmap)
+var curriedGoodMap = curry(goodMap)
+
+var goodDoubleArray = goodMap(x => x * 2)
+var badDoubleArray = badMap(_, x => x * 2)
++The bad version requires the curry function to support a magic +placeholder argument and doesn't look as clean. +
+13 Practical Currying
++Currying is not automatic in JavaScript, as in other languages +
+ ++External tools aren't (so far) able to statically analyse curried +functions +
+ ++Solution: Don't expose curried functions +Instead, write functions as if currying were automatic +
+ ++If consumers want to curry, they can. If they don't, their editor or +language server will show them the arguments +
+14 Functional composition
++Creating functions from other functions +
+ +
+Usually provided by compose (right-to-left) and pipe (left-to-right)
+
+A very simple definition of compose for only two functions would look like this
+
function compose (f, g) {
+ return function (...args) {
+ return f(g(...args))
+ }
+}
+15 Functional composition (cont.)
+var plusOne = x => x + 1
+var timesTwo = x => x * 2
+
+var plusOneTimesTwo = compose(timesTwo, plusOne)
+var timesTwoPlusOne = compose(plusOne, timesTwo)
+
+nextDoubled(3) // = (3 + 1) * 2 = 8
+doubledPlusOne(3) // = (3 * 2) + 1 = 7
+16 pipe
+
+What about pipe?
+
+pipe does the same thing, but runs the functions the other way around
+
+pipe(f, g) is the same as compose(g, f)
+
17 Point-free programming
++With currying and higher-order functions, we (often) don't need to declare function arguments +
+ +var modulo = a => b => b % a
+var eq = a => b => a === b
+
+var isEven = x => eq(0)(modulo(2)(x))
+var isEvenPointFree = compose(eq(0), modulo(2))
+18 Further Resources
+-
+
- Mostly adequate guide to FP (in javascript) +
- Ramda, a general-purpose FP library +
- Sanctuary, a JavaScript library for Haskellers +