feat: implement when

src/functions.js

@@ -349,5 +349,31 @@ module.exports = {
     if (fn.length === 0) throw new Error(`juxt: called with no arguments`);
     fn.forEach((f, i) => assert_function(f, `juxt: arg at ${i} is not a function`));
     return (...args) => fn.map(f => f(...args));
-  }
+  },
+
+  /**
+   * Returns `g(x)` if `f(x)` returns `true`.
+   * Returns `undefined` otherwise.
+   *
+   * @example
+   * ```javascript
+   * when(eq(40), add(2))(40);
+   * //=> 42
+   *
+   * when(eq(40), add(2))(41);
+   * //=> undefined
+   * ```
+   *
+   * @public
+   * @param {function(?): boolean} f Predicate. Must return `true` not thruthy.
+   * @param {function(?): ?} g Function applied to `x` if predicate is satisfied.
+   * @param {?} x
+   * @returns {?}
+   * @throws When either `f` or `g` is not a function
+   */
+  when: _curry((f, g, x) => {
+    assert_function(f, 'when: `f` is not a function');
+    assert_function(g, 'when: `g` is not a function');
+    if (f(x) === true) return g(x);
+  })
 };

test/when.test.js

@@ -0,0 +1,31 @@
+const td = require('testdouble');
+const test = require('tape');
+const {when: sut} =  require('..');
+
+test('when throws an error when either `f` or `g` is not a function', t => {
+  t.throws(() => sut(td.func())(42)('x'));
+  t.throws(() => sut(42)(td.func())('x'));
+  t.end();
+});
+
+test('when returns `g(x)` if `f(x)` returns `true`', t => {
+  const f = td.func();
+  const g = td.func();
+
+  td.when(f(1)).thenReturn(true);
+  td.when(f(2)).thenReturn(false);
+  td.when(f(3)).thenReturn('truthy');
+
+  td.when(g(1)).thenReturn('OK');
+
+  t.same(sut(f)(g)(1), 'OK',
+    'expected `g(x)` because f(x) returned `true`.');
+
+  t.same(sut(f)(g)(2), undefined,
+    'expected `undefined` because `f(x)` returned `false`.');
+
+  t.same(sut(f)(g)(3), undefined,
+    'expected `undefined` because `f(x)` returned truthy not `true`.');
+
+  t.end();
+});