Solutions

Author: ericelliott

source/index.js

@@ -0,0 +1,16 @@
+import curry from './curry';
+
+export const add2 = a => b => a + b;
+
+export const add3 = curry((a, b, c) => a + b + c);
+
+export const inc = add2(1);
+
+export const compose2 = (f, g) => x => f(g(x));
+
+export const trace = label => value => {
+  console.log(`${ label }: ${ JSON.stringify(value) }`);
+  return value;
+};
+
+export const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);

source/test.js

@@ -1,10 +1,97 @@
+// ES6 Curry & Function Composition
+
 import test from 'tape';
+import { add2 } from './index';
+import { add3 } from './index';
+import { inc } from './index';
+import { compose2 } from './index';
+import { trace } from './index';
+import { compose } from './index';
+
+// What is currying?
+// add2(a) => b => Number
+test('add2(a) => b => Number', assert => {
+  const msg = 'should take two numbers and return the sum';
+
+  const actual = add2(1)(2);
+  const expected = 3;
+
+  assert.same(actual, expected, msg);
+  assert.end();
+});
+
+// What is partial application?
+// add3(a) => b => c => Number
+test('add3(a) => b => c => Number', assert => {
+  const msg = 'should auto-curry arguments and return the sum';
+
+  const expected = 6;
+
+  assert.same(add3(1, 2, 3), expected, msg);
+  assert.same(add3(1)(2)(3), expected, msg);
+  assert.same(add3(1)(2, 3), expected, msg);
+  assert.same(add3(1, 2)(3), expected, msg);
+  assert.end();
+});
+
+// What is point-free style?
+// inc(n) => Number
+test('inc(n) => Number', assert => {
+  const msg = 'should take a number a and return the sum of a and 1';
+
+  const actual = inc(4);
+  const expected = 5;
+
+  assert.same(actual, expected, msg);
+  assert.end();
+});
+
+// What is function composition?
+// compose2(f: Function, g: Function) => Function
+// Given functions f and g, return the composition f ∘ g (f after g).
+// (f ∘ g)(x) = f(g(x))
+test('compose2(f: Function, g: Function) => Function', assert => {
+  const msg = 'should take two functions, f & g, and return f ∘ g';
+
+  const g = n => n + 1;
+  const f = n => n * 2;
+  const h = compose2(f, g);
+
+  const actual = h(20);
+  const expected = 42;
+
+  assert.same(actual, expected, msg);
+  assert.end();
+});
+
+// trace
+test('trace(label) => v => v, effects(log to console)', assert => {
+  const msg = 'should take a label and value and log, "label: value"';
+
+  const actual = trace('foo')('bar');
+  const expected = 'bar';
+
+  assert.same(actual, expected, msg);
+  assert.end();
+});
+
+// How does currying help with function composition?
+// compose(...fns: [...Functions]) => Function
+test('compose(...fns: [...Functions]) => Function', assert => {
+  const msg = 'should take any number of functions and return their composition';
+
+  const g = n => n + 1;
+  const f = n => n * 2;
 
-test('No tests yet!', assert => {
-  const msg = 'should have tests';
+  const h = compose(
+    trace('after f'),
+    f,
+    trace('after g'),
+    g
+  );
 
-  const actual = false;
-  const expected = true;
+  const actual = h(20);
+  const expected = 42;
 
   assert.same(actual, expected, msg);
   assert.end();