Deftype

lib/and.js

@@ -0,0 +1,20 @@
+module.exports = require('./variadic')(and)
+
+function and(x, rest) {
+  if (isEmpty(arguments)) return true
+
+  var result = val(x)
+
+  if (isnt(result) || isnt(rest)) return result
+
+  rest.every(function(x) {
+    return is(result = val(x))
+  })
+
+  return result
+}
+
+const isEmpty = require('./isEmpty') 
+    , isnt    = require('./isnt')
+    , val     = require('./val')
+    , is      = require('./is')

lib/apply.js

@@ -2,8 +2,7 @@ module.exports = apply
 
 function apply(fn, args) {
   if (isnt(Function, fn)) throw new TypeError('First argument must be a function.')
-
-  fn.apply(this, args)
+  return fn.apply(this, args)
 }
 
 const isnt = require('./isnt')

lib/assert.js

@@ -0,0 +1,15 @@
+module.exports = assert
+
+function assert(x, message, type) {
+  if (isnt(x)) {
+    message = val(message)
+    isnt(message) && (message = "Assertion failed.")
+    throw is(Error, message)? message : Error(message)
+  }
+
+  return x
+}
+
+const isnt = require("./isnt")
+    , val  = require("./val")
+    , is   = require("./is")

lib/defprop.js

@@ -0,0 +1,52 @@
+module.exports = defprop
+
+function defprop(target, fields, opts) {
+  if (isnt(target)) throw TypeError("Target must exist.")
+  if (isnt(fields)) throw TypeError("Fields must exist.")
+
+  opts || (opts = {})
+
+  const names  = Object.getOwnPropertyNames(fields)
+
+  const isMutable = get(opts, "^writable", false)
+      , isEnum    = get(opts, "^enumerable", false)
+      , isConf    = get(opts, "^configurable", false)
+      , scope     = get(opts, "^bind", false)
+
+  return Object.defineProperties(target,
+    names.reduce(function(p, k) {
+      const prop = describe(fields, k)
+          , opt  = $(get, opts[k])
+
+      if (isnt(prop.get) && isnt(prop.set)) {
+        prop.writable = opt("writable", isMutable)
+
+        when(is(Function, prop.value) && opt("bind", scope), function(scope) {
+          prop.value = prop.value.bind(scope)
+        })
+      } else {
+        when(prop.get && opt("writable") && !prop.set, function() {
+          throw TypeError("The accessor `"+k+"` can't be writable without a setter.")
+        })
+
+        when(opt("bind", scope), function(scope) {
+          prop.get && (prop.get = prop.get.bind(scope))
+          prop.set && (prop.set = prop.set.bind(scope))
+        })
+      }
+
+      prop.enumerable   = opt("enumerable", isEnum)
+      prop.configurable = opt("configurable", isConf)
+
+      return (p[k] = prop), p
+    }, {})
+  )
+}
+
+const describe = Object.getOwnPropertyDescriptor
+    , isEmpty  = require("./isEmpty")
+    , isnt     = require("./isnt")
+    , when     = require("./when")
+    , get      = require("./get")
+    , is       = require("./is")
+    , $        = require("./partial")

lib/describe.js

@@ -0,0 +1,28 @@
+module.exports = require("./variadic")(describe)
+
+function describe(obj, fields) {
+  assert(is(Object.prototype, obj), TypeError("Can't describe non-object: " + src(obj)))
+
+  const descprop = $(Object.getOwnPropertyDescriptor, obj)
+
+  if (is(fields)) {
+    const hasprop = obj.hasOwnProperty.bind(obj)
+        , props   = []
+
+    return fields.map(function(name) {
+      assert(hasprop(name), TypeError("Can't describe non-existant property: " + name))
+      return [name, descprop(name)]
+    })
+  } else {
+    return names(obj).map(function(name) {
+      return [name, descprop(name)]
+    }, {})
+  }
+}
+
+const assert = require("./assert")
+    , names  = Object.getOwnPropertyNames
+    , each   = require("./each")
+    , src    = require("./src")
+    , is     = require("./is")
+    , $      = require("./partial")

lib/extend.js

@@ -0,0 +1,23 @@
+module.exports = require("./variadic")(extend)
+
+function extend(base, rest) {
+  assert(isExtendable(base), TypeError("Base must be an extendable object."))
+  assert(is(rest), TypeError("At least one extension object must be defined."))
+
+  const traits = describe(apply(merge, rest)).reduce(function(traits, prop) {
+    traits[prop[0]] = prop[1]
+    return traits
+  }, {})
+
+  return Object.create(base, traits)
+}
+
+const describe = require("./describe")
+    , assert   = require("./assert")
+    , apply    = require("./apply")
+    , merge    = require("./merge")
+    , comp     = require("./comp")
+    , is       = require("./is")
+    , $        = require("./partial")
+
+const isExtendable = $(is, Object.prototype)

lib/get.js

@@ -0,0 +1,11 @@
+module.exports = get
+
+function get(map, key, notFound) {
+  if (isnt(map)) return notFound
+  if (!map.hasOwnProperty(key)) return notFound
+
+  return map[key]
+}
+
+const isnt = require('./isnt')
+    , is   = require('./is')

lib/is.js

@@ -5,6 +5,8 @@ function is(c, x) {
     return !not(c)
   }
 
+  if (c === x) return true
+
   const cs = lowerCase(c)
 
   if (cs === 'null') {
@@ -18,7 +20,7 @@ function is(c, x) {
   } else if (type(c) === 'string') {
     return cs === type(x)
   } else {
-    return is(x) && x.constructor === c || c.isPrototypeOf(x)
+    return (x != null && x.constructor === c) || c.isPrototypeOf(x)
   }
 }
 

lib/merge.js

@@ -0,0 +1,18 @@
+module.exports = require("./variadic")(merge)
+
+function merge(objects) {
+  if (isEmpty(objects)) return
+
+  return create(Object.prototype, objects.reduce(function(fields, t) {
+    names(t).forEach(function(k) {
+      fields[k] = describe(t, k)
+    })
+
+    return fields
+  }, {}))
+}
+
+const describe = Object.getOwnPropertyDescriptor
+    , isEmpty  = require("./isEmpty")
+    , create   = Object.create
+    , names    = Object.getOwnPropertyNames

lib/partial.js

@@ -1,12 +1,17 @@
-module.exports = partial
+const $ = module.exports = require("./variadic")(partial)
 
-function partial(fun, args) {
-  if (arguments.length === 1) return fun
+function partial(fun, part) {
+  if (isnt(part)) return fun
 
-  const part = [].slice.call(arguments, 1)
+  return variadic(function(rest) {
+    const args = part.map(function(arg) {
+      return arg === $? rest.shift() : arg
+    })
 
-  return function partial() {
-    const rest = [].slice.call(arguments)
-    return fun.apply(this, part.concat(rest))
-  }
-}
+    return fun.apply(this, args.concat(rest))
+  })
+}
+
+const variadic = require("./variadic")
+    , each     = require("./each")
+    , isnt     = require("./isnt")

lib/thunk.js

@@ -1,19 +1,12 @@
 module.exports = require('./variadic')(thunk)
 
 function thunk(fn, rest) {
-  if (isnt(Function, fn)) {
-    rest = [fn]
-    fn = identity
-  }
+  if (isnt(Function, fn)) throw new TypeError('Expected `fn` to be a function.')
 
-  if (rest.length > 1) {
+  if (is(rest)) {
     return function thunk() {
       return fn.apply(this, rest)
     }
-  } else if (rest.length) {
-    return function thunk() {
-      return fn.call(this, rest[0])
-    }
   } else {
     return function thunk() {
       return fn.call(this)
@@ -23,4 +16,5 @@ function thunk(fn, rest) {
 
 const identity = require('./identity')
     , slice    = require('./slice')
-    , isnt     = require('./isnt')
+    , isnt     = require('./isnt')
+    , is       = require('./is')

lib/val.js

@@ -0,0 +1,8 @@
+module.exports = require('./variadic')(val)
+
+function val(x, rest) {
+  return is(Function, x)? apply(x, rest) : x
+}
+
+const apply = require('./apply')
+    , is    = require('./is')

lib/variadic.js

@@ -2,23 +2,49 @@ module.exports = variadic
 
 function variadic(fn) {
   if (isnt(Function, fn)) throw new TypeError('Parameter `fn` must be a function.')
+
+  const argc = fn.length - 1
 
-  const argc  = fn.length - 1
-
-  if (argc) {
-    return function variadic() {
-      const head = slice(arguments, 0, argc)
-          , tail = slice(arguments, argc)
-
-      return fn.apply(this, head.concat([tail]))
-    }
-  } else {
-    return function variadic() {
-      const rest = slice(arguments)
-      return fn.call(this, rest)
-    }
+  switch (argc) {
+    case -1 : return fn
+    case  0 : return function (rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  1 : return function (a, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  2 : return function (a, b, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  3 : return function (a, b, c, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  4 : return function (a, b, c, d, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  5 : return function (a, b, c, d, e, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  6 : return function (a, b, c, d, e, f, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  7 : return function (a, b, c, d, e, f, g, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  8 : return function (a, b, c, d, e, f, g, h, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case  9 : return function (a, b, c, d, e, f, g, h, i, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 10 : return function (a, b, c, d, e, f, g, h, i, j, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 11 : return function (a, b, c, d, e, f, g, h, i, j, k, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 12 : return function (a, b, c, d, e, f, g, h, i, j, k, l, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 13 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 14 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 15 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 16 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 17 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 18 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 19 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 20 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 21 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 22 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 23 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 24 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, rest) { return apply(fn, this, argc, slice(arguments)) }
+    case 25 : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, rest) { return apply(fn, this, argc, slice(arguments)) }
+    default : return function (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, rest) { return apply(fn, this, argc, slice(arguments)) }
   }
 }
 
-const slice = require('./slice')
-    , isnt  = require('./isnt')
+function apply(fn, host, argc, argv) {
+  const rest = slice(argv, argc)
+  argv = slice(argv, 0, argc)
+  return isEmpty(rest)? fn.apply(host, argv) : fn.apply(host, argv.concat([rest]))
+}
+
+const isEmpty = require('./isEmpty')
+    , slice   = require('./slice')
+    , isnt    = require('./isnt')
+    , min     = require('./min')
+    , max     = Math.max

lib/when.js

@@ -0,0 +1,9 @@
+module.exports = when
+
+function when(cond, body) {
+  const it = val(cond)
+  return is(it)? val(body, it) : null
+}
+
+const val = require('./val')
+    , is  = require('./is')