Add chapter on functions

Aaron O'Mullan · Aaron O'Mullan · commit 12cef390252f · 2014-04-02T20:20:40.000-07:00
diff --git a/SUMMARY.md b/SUMMARY.md
@@ -19,4 +19,7 @@
     * [Concatenate](conditional/concatenate.md)
 * [Loops](loops/README.md)
     * [For](loops/for.md)
-    * [While](loops/while.md)
+    * [While](loops/while.md)
+* [Functions](functions/README.md)
+    * [Declare](functions/declare.md)
+    * [Higher order](functions/higher_order.md)
diff --git a/functions/README.md b/functions/README.md
@@ -0,0 +1,6 @@
+# Functions
+
+Functions, are one of the most powerful and essential notions in programming.
+
+Functions like mathematical functions perform transformations, they take input values called **arguments** and **return** an output value.
+
diff --git a/functions/declare.md b/functions/declare.md
@@ -0,0 +1,40 @@
+# Declaring Functions
+
+Functions like variables must be declared. Lets declare a function `double` which accepts an **argument** called `x` and **returns** the double of x :
+
+```javascript
+function double(x) {
+    return 2 * x;
+}
+```
+
+Functions are also values in JavaScript, they can be stored in variables (just like numbers, strings, etc ...) and given to other functions as arguments :
+
+```javascript
+var double = function(x) {
+    return 2 * x;
+};
+```
+
+---
+
+Declare a function named `triple` that takes and argument and returns it's triple.
+
+```js
+
+```
+
+```js
+var triple = function(x) {
+    return x * 3;
+}
+```
+
+```js
+assert(triple);
+assert(triple(4) === 12);
+assert(triple(10) === 30);
+```
+
+---
+
diff --git a/functions/higher_order.md b/functions/higher_order.md
@@ -0,0 +1,81 @@
+# Higher Order Functions
+
+Higher order functions, are functions that accept other functions as arguments or return a function it generates.
+
+This is a *fancy* and extremely powerful construct available in JavaScript and other high-level languages (python, lisp, ...)
+
+Now lets pass our `double` function as an argument to another function called `transform` :
+
+```javascript
+// Our double function
+var double = function(x) {
+    return 2 * x;
+};
+
+// A function that accepts two arguments
+// first the function to call
+// second the value to call it on
+var transform = function(func, value) {
+    return func(value);
+}
+
+// This does the same as double(3)
+transform(double, 3);
+```
+
+The above example was intentionally simple, having functions as values grants enormous flexibility and allows for many powerful constructs.
+
+Now lets create a function called `buildMultiplier` that takes a number `x` and returns a function that multiplies it's argument by `x` :
+
+```javascript
+var buildMultiplier = function(x) {
+    return function(y) {
+        return x * y;
+    }
+}
+
+var double = buildMultilplier(2);
+var triple = buildMultilplier(3);
+
+double(3); // => 6
+triple(3); // => 9
+```
+
+---
+
+Define a function named `negate` that takes `add1` as argument and returns a function, that returns the opposite of the value returned by `add`. (Things get a bit more complicated ;) )
+
+```js
+var add1 = function (x) {
+    return x + 1;
+};
+
+var negate = function(func) {
+    // TODO
+};
+
+// Should return -6
+// Because (5+1) * -1 = -6
+negate(add1)(5);
+
+```
+
+```js
+var add1 = function (x) {
+    return x + 1;
+}
+
+var negate = function(func) {
+    return function(x) {
+        return -1 * func(x);
+    }
+}
+
+negate(add1)(5);
+```
+
+```js
+assert(negate(add1)(5) === -6);
+```
+
+---
