Update instructions

Author: ihollander

README.md

@@ -16,32 +16,33 @@ Imagine an exercise routine: every morning, we run 5 miles. But afterwards —
 depending on the day — we might lift weights, go for a swim, or run an extra 5
 miles.
 
-In programming-speak, we could write out a function for every day (follow along!):
+In programming-speak, we could write out a function for every day (follow along
+by writing out these examples in a REPL, or in the `index.js` file!):
 
 ```js
 function Monday() {
-  console.log('Go for a five-mile run');
-  console.log('Pump iron');
+  console.log("Go for a five-mile run");
+  console.log("Pump iron");
 }
 
 function Tuesday() {
-  console.log('Go for a five-mile run');
-  console.log('Swim 40 laps');
+  console.log("Go for a five-mile run");
+  console.log("Swim 40 laps");
 }
 
 function Wednesday() {
-  console.log('Go for a five-mile run');
-  console.log('Go for a five-mile run');
+  console.log("Go for a five-mile run");
+  console.log("Go for a five-mile run");
 }
 
 function Thursday() {
-  console.log('Go for a five-mile run');
-  console.log('Pump iron');
+  console.log("Go for a five-mile run");
+  console.log("Pump iron");
 }
 
 function Friday() {
-  console.log('Go for a five-mile run');
-  console.log('Swim 40 laps');
+  console.log("Go for a five-mile run");
+  console.log("Swim 40 laps");
 }
 ```
 
@@ -52,7 +53,7 @@ What if we pull all of our five-mile runs into their own function?
 
 ```js
 function runFiveMiles() {
-  console.log('Go for a five-mile run');
+  console.log("Go for a five-mile run");
 }
 ```
 
@@ -61,15 +62,15 @@ same thing for lifting weights and swimming:
 
 ```js
 function liftWeights() {
-  console.log('Pump iron');
+  console.log("Pump iron");
 }
 
 function swimFortyLaps() {
-  console.log('Swim 40 laps');
+  console.log("Swim 40 laps");
 }
 ```
 
-Awesome! We've cut down a little bit more: `Monday()` could now look like
+Awesome! We've cut down a little bit more: `Monday()` could now look like:
 
 ```js
 function Monday() {
@@ -99,12 +100,17 @@ to use this new function we created in our `Monday()` function:
 function Monday() {
   exerciseRoutine(liftWeights);
 }
+
+function exerciseRoutine(postRunActivity) {
+  runFiveMiles();
+  postRunActivity();
+}
 ```
 
-Note that we aren't _calling_ `liftWeights`. When we want to pass a function
-as a value, we pass it by _reference_ by omitting the parentheses. We're not
-running the function at this point. It's up to `exerciseRoutine()` to call the
-function when it is needed.
+Note that we aren't _calling_ `liftWeights`. When we want to pass a function as
+a value, we pass it by _reference_ by omitting the parentheses at the end of the
+function. We're not running the function at this point. It's up to
+`exerciseRoutine()` to call the function when it is needed.
 
 If we call `Monday()`, we'll see that we run five miles, and then we lift
 weights — awesome!
@@ -130,8 +136,8 @@ defined beforehand! We can pass an _anonymous function_ to `exerciseRoutine()`.
 To start with, let's use the full function syntax we've come to know and love:
 
 ```js
-exerciseRoutine(function() {
-  console.log('Stretch! Work that core!');
+exerciseRoutine(function () {
+  console.log("Stretch! Work that core!");
 });
 
 // "Go for a five-mile run"
@@ -142,11 +148,11 @@ We can rewrite this to be more concise by using an arrow function:
 
 ```js
 exerciseRoutine(() => {
-  console.log('Stretch! Work that core!');
+  console.log("Stretch! Work that core!");
 });
 
 // Or even shorter:
-exerciseRoutine(() => console.log('Stretch! Work that core!'));
+exerciseRoutine(() => console.log("Stretch! Work that core!"));
 ```
 
 Because we only need to use our function this one time, there's no need to give
@@ -170,20 +176,20 @@ function morningRoutine(exercise) {
   let breakfast;
 
   if (exercise === liftWeights) {
-    breakfast = 'protein bar';
+    breakfast = "protein bar";
   } else if (exercise === swimFortyLaps) {
-    breakfast = 'kale smoothie';
+    breakfast = "kale smoothie";
   } else {
-    breakfast = 'granola';
+    breakfast = "granola";
   }
 
   exerciseRoutine(exercise);
 
   // we could give this function a name if we wanted to, but since
   // it's only available _inside_ morningRoutine(), we don't need to
-  return function() {
+  return function () {
     console.log(`Nom nom nom, this ${breakfast} is delicious!`);
-  }
+  };
 }
 ```
 
@@ -210,7 +216,29 @@ If you haven't been following along, it's vitally important that you go back and
 do so. First-class functions are one of JavaScript's most powerful features, but
 it takes some practice for them to sink in.
 
+## Instructions
+
+To get more practice with first-class functions, this lesson has three tests to
+pass that require you to write the following functions in the `index.js` file:
+
+- The `receivesAFunction` function should:
+
+  - take a _callback function_ as an argument
+  - call the callback function
+  - it doesn't matter what this function returns, so long as it calls the
+    callback function
+
+- The `returnsANamedFunction` function should:
+
+  - take no arguments
+  - return a _named function_
+
+- The `returnsAnAnonymousFunction` function should:
+  - take no arguments
+  - return an _anonymous function_
+
 ## Resources
 
-- [Wikipedia](https://en.wikipedia.org/wiki/First-class_function): [First-class function](https://en.wikipedia.org/wiki/First-class_function)
-- [JavaScript is Sexy](http://javascriptissexy.com/understand-javascript-callback-functions-and-use-them/#more-1037): [Higher-order functions](http://javascriptissexy.com/understand-javascript-callback-functions-and-use-them/#more-1037)
+- [Wikipedia: First-class function](https://en.wikipedia.org/wiki/First-class_function)
+- [JavaScript is Sexy: Higher-order functions](http://javascriptissexy.com/understand-javascript-callback-functions-and-use-them/#more-1037)
+- [MDN Function Expression (named vs anonymous functions)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function)

test/index-test.js

@@ -1,53 +1,63 @@
-const expect = require('expect')
-const fs = require('fs')
-const jsdom = require('mocha-jsdom')
-const path = require('path')
+const expect = require("expect");
+const fs = require("fs");
+const jsdom = require("mocha-jsdom");
+const path = require("path");
 
-
-describe('index', () => {
+describe("index", () => {
   jsdom({
-    src: fs.readFileSync(path.resolve(__dirname, '..', 'index.js'), 'utf-8')
-  })
+    src: fs.readFileSync(path.resolve(__dirname, "..", "index.js"), "utf-8"),
+  });
 
-  describe('receivesAFunction(callback)', () => {
-    it('receives a function and calls it', () => {
-      const spy = expect.createSpy()
+  describe("receivesAFunction(callback)", () => {
+    it("receives a function and calls it", () => {
+      // in the context of this test, 'spy' is the callback function
+      const spy = expect.createSpy();
 
-      receivesAFunction(spy)
+      // your function should take a callback function as an argument
+      receivesAFunction(spy);
 
-      expect(spy).toHaveBeenCalled()
-    })
-  })
+      // and it should call the callback function
+      expect(spy).toHaveBeenCalled();
+    });
+  });
 
-  describe('returnsANamedFunction()', () => {
-    var fn
+  describe("returnsANamedFunction()", () => {
+    let fn;
 
     before(() => {
-      fn = returnsANamedFunction()
-    })
+      // before running each test, we call your 'returnsANamedFunction' function
+      // and save its return value to a variable called 'fn'
+      fn = returnsANamedFunction();
+    });
+
+    it("returns a function", () => {
+      expect(fn).toBeA("function");
+    });
 
-    it('returns a function', () => {
-      expect(fn).toBeA('function')
-    })
+    it("returns a named function", () => {
+      // if you declare a function with the syntax:
+      // function myFunction() {}
+      // it will have a name "myFunction" assigned to its name property
 
-    it('returns a named function', () => {
-      expect(fn.name).toNotEqual('')
-    })
-  })
+      // this checks that the function returned from 'returnsANamedFunction'
+      // has a name assigned
+      expect(fn.name).toNotEqual("");
+    });
+  });
 
-  describe('returnsAnAnonymousFunction()', () => {
-    var fn
+  describe("returnsAnAnonymousFunction()", () => {
+    let fn;
 
     before(() => {
-      fn = returnsAnAnonymousFunction()
-    })
-
-    it('returns a function', () => {
-      expect(fn).toBeA('function')
-    })
-
-    it('returns an anonymous function', () => {
-      expect(fn.name).toEqual('')
-    })
-  })
-})
+      fn = returnsAnAnonymousFunction();
+    });
+
+    it("returns a function", () => {
+      expect(fn).toBeA("function");
+    });
+
+    it("returns an anonymous function", () => {
+      expect(fn.name).toEqual("");
+    });
+  });
+});