Colocate all library code browserable teep.js

earldouglas · Jun 11, 2015 · 8a76189 · 8a76189
1 parent 5e6a427
commit 8a76189
Show file tree

Hide file tree

Showing 8 changed files with 176 additions and 191 deletions.
diff --git a/lib/array.js b/lib/array.js
diff --git a/lib/function.js b/lib/function.js
diff --git a/lib/list.js b/lib/list.js
diff --git a/lib/option.js b/lib/option.js
diff --git a/lib/promise.js b/lib/promise.js
diff --git a/lib/validation.js b/lib/validation.js
diff --git a/package.json b/package.json
@@ -27,7 +27,7 @@
   },
   "scripts": {
     "test": "nodeunit test",
-    "coveralls": "jscoverage lib && LIB_COV=1 nodeunit --reporter=lcov test | coveralls"
+    "coveralls": "jscoverage teep.js teep.js && nodeunit --reporter=lcov test | coveralls"
   },
   "devDependencies": {
     "bluebird": "2.2.2",

diff --git a/teep.js b/teep.js
@@ -8,19 +8,178 @@
 
 'use strict';
 
-// Use instrumented code for code coverage tests
-var lib = process.env.LIB_COV ? 'lib-cov' : 'lib';
-
-var option     = require('./' + lib + '/option');
-var validation = require('./' + lib + '/validation');
-var list       = require('./' + lib + '/list');
-var promise    = require('./' + lib + '/promise');
-var fn         = require('./' + lib + '/function');
-var array      = require('./' + lib + '/array');
-
-exports.option     = option;
-exports.validation = validation;
-exports.list       = list;
-exports.promise    = promise;
-exports.fn         = fn;
-exports.array      = array;
+var edc;
+(function (edc) {
+
+  var array = {
+    contains: function (xs, x) {
+      for (var i = 0; i < xs.length; i++) {
+        if (xs[i] === x) {
+          return true;
+        }
+      }
+      return false;
+    },
+  };
+
+  var fn = {
+    compose: function (f, g) {
+      return function (x) {
+        return f(g(x));
+      };
+    },
+    curry: function (f, args) {
+      if (!args || !args.length) {
+        args = [];
+      }
+      return function(x) {
+        args.push(x);
+        if (f.length === args.length) {
+          return f.apply(null, args);
+        } else {
+          return fn.curry(f, args);
+        }
+      };
+    },
+    memoize: function (f, cache) {
+      if (!cache) {
+        cache = {
+          get: function(k)   { return cache[k]; },
+          put: function(k,v) { cache[k] = v;    },
+        };
+      }
+      return function () {
+        var key = (arguments.length === 0) ?
+          arguments[0] : JSON.stringify(arguments);
+        var val = cache.get(key);
+        if (val === undefined) {
+          val = f.apply(undefined, arguments);
+          cache.put(key, val);
+          return val;
+        } else {
+          return val;
+        }
+      };
+    },
+    lazy: function (f, cache) {
+      var fMemo = fn.memoize(f, cache);
+      return function() {
+        var args = arguments;
+        return {
+          get: function() { return fMemo.apply(undefined, args); }
+        };
+      };
+    },
+  };
+
+  var option = function (value) {
+    if (value || value === false || value === 0 || value === '') {
+      return {
+        empty    : false,
+        map      : function(f) { return option(f(value)); },
+        flatMap  : function(f) { return f(value); },
+        ap       : function(a) { return a.map(value); },
+        toString : function()  { return 'some(' + value.toString() + ')'; }
+      };
+    } else {
+      return {
+        empty    : true,
+        map      : function() { return this; },
+        flatMap  : function() { return this; },
+        ap       : function() { return this; },
+        toString : function() { return 'none()'; }
+      };
+    }
+  };
+
+  var validation = {
+    valid: function (value) {
+      return {
+        valid    : true,
+        value    : value,
+        map      : function(f) { return validation.valid(f(value)); },
+        flatMap  : function(f) { return f(value); },
+        ap       : function(a) { return a.map(value); },
+        toString : function()  { return 'valid(' + value.toString() + ')'; }
+      };
+    },
+    invalid: function (errors) {
+      var self = {
+        valid    : false,
+        errors   : errors,
+        map      : function() { return self; },
+        flatMap  : function() { return self; },
+        ap       : function(a) {
+                     if (a.valid) {
+                       return self;
+                     } else {
+                       return validation.invalid(errors.concat(a.errors));
+                     }
+                   },
+        toString : function() { return 'invalid(' + errors.toString() + ')'; }
+      };
+      return self;
+    },
+  };
+
+  var list = function (head, tail) {
+    var _nil = {
+      length   : 0,
+      map      : function() { return this; },
+      flatMap  : function() { return this; },
+      concat   : function(l) { return l; },
+      toString : function() { return 'nil'; }
+    };
+    var _cons = function (head, tail) {
+      return {
+        head     : head,
+        tail     : tail,
+        length   : 1 + tail.length,
+        map      : function(f) { return _cons(f(head), tail.map(f)); },
+        flatMap  : function(f) { return f(head).concat(tail.flatMap(f)); },
+        concat   : function(l) { return _cons(head, tail.concat(l)); },
+        toString : function() {
+                     return 'cons(' + head + ', ' + tail.toString() + ')';
+                   }
+      };
+    };
+
+    if (tail === undefined || tail === null) {
+      return list(head, _nil);
+    } else if (head === undefined || head === null) {
+      return tail;
+    } else {
+      return _cons(head, tail);
+    }
+  };
+
+  var promise = {
+    collect: function (promises, callback) {
+        var f = fn.curry(callback);
+        var p = promises.reduce(function (p1, p2) {
+            return p1.then(function (r1) {
+                f = f(r1);
+                return (p2 instanceof Function) ? p2() : p2;
+            });
+        });
+        return p.then(function (r) { return f(r); });
+    }
+  };
+
+  edc.teep = {
+    array: array,
+    fn: fn,
+    option: option,
+    validation: validation,
+    list: list,
+    promise: promise,
+  };
+
+  for (var i in edc.teep) {
+    if (edc.teep.hasOwnProperty(i)) {
+      exports[i] = edc.teep[i];
+    }
+  }
+
+})(edc || (edc = {}));
+