(val: Value, ...fns: Function) => Value
173068
function pipe(val) {
  var fns = slice.call(arguments, 1)
  return fns.reduce(function (val, fn) {
    return fn(val)
  }, val)
}
153176
function evaluate(val, context) {
        if ($.isFunction(val)) {
            var args = Array.prototype.slice.call(arguments, 2);
            return val.apply(context, args);
        }
        return val;
    }
202137
function (successValue, failValue, fns) {
            for (var i = 0; i < fns.length; i++) {
                var o = fns[i][0][fns[i][1]].apply(fns[i][0], fns[i][2]);
                if (o === failValue) {
                    return o;
                }
            }
            return successValue;
        }
959168
function map(fn, ctx) {
  assert.equal(typeof fn, 'function')
  return function(val) {
    val = Array.isArray(val) ? val : [val]
    return Promise.all(val.map(fn, ctx))
  }
}
924195
function(value, text) {
      text = (typeof text == 'string')
        ? text.toLowerCase()
        : text
      ;
      value = (typeof value == 'string')
        ? value.toLowerCase()
        : value
      ;
      return (value == text);
    }
1110795
function mapValues(fn, obj) {
  return keys(obj).reduce(function(acc, key) {
    acc[key] = fn(obj[key]);
    return acc;
  }, {});
}
276455
function isBuffer(val) {
  if (val.constructor && typeof val.constructor.isBuffer === 'function') {
    return val.constructor.isBuffer(val);
  }
  return false;
}
81473
function S(fn, value) {
    var owner = Owner, clock = RunningClock === null ? RootClock : RunningClock, running = RunningNode;
    if (owner === null)
        console.warn("computations created without a root or parent will never be disposed");
    var node = new ComputationNode(clock, fn, value);
    Owner = RunningNode = node;
    if (RunningClock === null) {
        toplevelComputation(node);
    }
    else {
        node.value = node.fn(node.value);
    }
    if (owner && owner !== UNOWNED) {
        if (owner.owned === null)
            owner.owned = [node];
        else
            owner.owned.push(node);
    }
    Owner = owner;
    RunningNode = running;
    return function computation() {
        if (RunningNode !== null) {
            var rclock = RunningClock, sclock = node.clock;
            while (rclock.depth > sclock.depth + 1)
                rclock = rclock.parent;
            if (rclock === sclock || rclock.parent === sclock) {
                if (node.preclocks !== null) {
                    for (var i = 0; i < node.preclocks.count; i++) {
                        var preclock = node.preclocks.clocks[i];
                        updateClock(preclock);
                    }
                }
                if (node.age === node.clock.time()) {
                    if (node.state === RUNNING)
                        throw new Error("circular dependency");
                    else
                        updateNode(node); // checks for state === STALE internally, so don't need to check here
                }
                if (node.preclocks !== null) {
                    for (var i = 0; i < node.preclocks.count; i++) {
                        var preclock = node.preclocks.clocks[i];
                        if (rclock === sclock)
                            logNodePreClock(preclock, RunningNode);
                        else
                            logClockPreClock(preclock, rclock, RunningNode);
                    }
                }
            }
            else {
                if (rclock.depth > sclock.depth)
                    rclock = rclock.parent;
                while (sclock.depth > rclock.depth + 1)
                    sclock = sclock.parent;
                if (sclock.parent === rclock) {
                    logNodePreClock(sclock, RunningNode);
                }
                else {
                    if (sclock.depth > rclock.depth)
                        sclock = sclock.parent;
                    while (rclock.parent !== sclock.parent)
                        rclock = rclock.parent, sclock = sclock.parent;
                    logClockPreClock(sclock, rclock, RunningNode);
                }
                updateClock(sclock);
            }
            logComputationRead(node, RunningNode);
        }
        return node.value;
    };
}
1327559
function (type, fn) {
  var result;
  try {
    result = fn();
  }
  catch (e) {
    result = {error: e};
  }

  if (result && !result.type && type)
    result.type = type;

  return result;
}
561831
def _setVal(self, name, val, defVal = None):
        """"""
        if val == defVal:
            return
        if not hasattr(self, "vals"):
            self.vals = {}
        self.vals[name] = val
228791
function reduceVal(conf, val) {
  val = val.call(conf);
  return typeof val === 'function' ? reduceVal(conf, val) : val;
}
1099937
function value(val, buf, simple) {
  buf = buf || new Buffer(0);
  var type = typeof val;

  // coerce booleans to integers
  val = type === 'boolean' ? Number(val) : val;

  // treat floats as strings
  if(type === 'number' && parseInt(val) !== val) {
    val = '' + val;
  }

  // String instances are treated as simple strings
  if(val instanceof String) {
    simple = true;
    val = val.toString();
  }

  // re-evaluate type after coercion
  type = typeof val;

  if(val instanceof Buffer) {
    buf = _bst(buf, val);
  }else if(val === null) {
    buf = _nil(buf);
  }else if(Array.isArray(val)) {
    buf = _arr(buf, val);
  }else if(type === 'number'){
    buf = _int(buf, val);
  }else if(type === 'string') {
    buf = simple ? _str(buf, val) : _bst(buf, val);
  }else if(val instanceof Error) {
    buf = _err(buf, val);
  }else{
    assert(false, 'invalid encoder type: ' + type);
  }
  return buf;
}
1231698
function val(newVal) {
      var query;

      if (!arguments.length) {
        ttEach(this.first(), function(t) { query = t.getVal(); });
        return query;
      }

      else {
        ttEach(this, function(t) { t.setVal(newVal); });
        return this;
      }
    }
840925
function val (params, spec, errs) {
  for (var key in params) {
    if (key in spec && isFunction(spec[key].val) && !spec[key].val(params[key])) valError(key, errs)
  }
}
130257
function fv(vals, key) {
  if (!vals) return;
  vals.forEach(function(v) {
    if (v.key === key && vals[key] !== 'Not available') {
      return vals[key];
    }
  });
}
437711
function ( qu, value ) {
		return (sys.isNull( value ) || sys.isUndefined( value )) !== qu.operands[0];
	}
301590
function (it, S) {
  if (!_isObject(it)) return it;
  var fn, val;
  if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
  if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val;
  if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
  throw TypeError("Can't convert object to primitive value");
}