Lazily evaluate the value

@param {Any} obj
@param {Function} fn
328096
function get(obj, fn) {
  if (typeof obj === 'object') return fn(null, obj);
  if (typeof obj === 'undefined') return fn(null, {});
  if (typeof obj !== 'function') return fn(new Error('cannot read conf:\n' + obj));
  if (obj.length === 1) return obj(fn);
  var val;
  try {
    val = obj();
  } catch(err) {
    return fn(err);
  }
  fn(null, val);
}
29101
function $$safeEvalFn(str) {
    let keyStr = '';

    // Perform any parsing that needs to be performed on the scope value
    for (let key in this) {
        let val = this[ key ];
        if (!val && val !== 0 && val !== '') {
            continue;
        } else if (
            typeof val === 'symbol' ||
            typeof val === 'string'
        ) {
            val = `"${val}"`;
        } else if (typeof val === 'object') {
            val = JSON.stringify(val);
        }

        // I don't like having to use var here
        keyStr += `var ${key}=${val};`;
    }

    // Literal eval is executed in its own context here to reduce security issues
    /* eslint-disable */
    return eval([ keyStr, str ].join(''));

    /* eslint-enable */
}
467294
function mapValues (obj, fn) {
  return Object.keys(obj).reduce(function (subresult, key) {
    subresult[key] = fn(obj[key], key)
    return subresult
  }, {})
}
35430
function ( obj ) {
		if ( typeof obj.reset === "function" ) {
			obj.reset();
		}
		else if ( obj.value !== undefined ) {
			element.update( obj, {innerHTML: "", value: ""} );
		}
		else {
			element.update( obj, {innerHTML: ""} );
		}

		return obj;
	}
1242123
function toFn (value) {
  if (typeof value === 'function') return value

  var str = Array.isArray(value) ? value : String(value)
  var obj = Object.create(null)

  for (var i = 0; i < str.length; i++) {
    obj[str[i]] = true
  }

  return function (char) {
    return obj[char]
  }
}
431826
function ( obj, fn ) {
		var result = [];

		array.each( obj, function ( i ) {
			result.push( fn( i ) );
		});

		return result;
	}
724007
function dig(obj) {
  var iterateeFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (val, key, iterableParent) {
    return val;
  };
  // eslint-disable-line no-unused-vars
  // modifierFn = v => v,
  return (0, _each2.default)(obj, function iterator(itValue, key, itObj) {
    var processedItValue = itValue;
    // console.log("processedItValue (before)", processedItValue)
    if ((0, _is.isIterable)(itValue, { objects: true })) {
      // console.log("Is iterable, key:", key)
      processedItValue = (0, _each2.default)(itValue, iterator); // , iterateeFn
    }
    var iterateeReturnedValue = iterateeFn(processedItValue, key, itObj);
    // console.log("iterateeReturnedValue", iterateeReturnedValue)
    if ((0, _is.isObject)(iterateeReturnedValue) && (0, _is.isLength)((0, _toKeys2.default)(iterateeReturnedValue), 1) && (0, _get2.default)(iterateeReturnedValue, "$remove", false) === true) {
      return { $remove: true };
    } else if ((0, _is.isDefined)(iterateeReturnedValue)) {
      return iterateeReturnedValue;
    } else {
      // console.log("processedItValue (after)", processedItValue)
      return processedItValue;
    }
  }
  //,  iterateeFn
  );
}
630421
function(obj, functName, attr) {
    if (d4.isNotFunction(attr)) {
      var prop = '$' + functName;
      readOnlyProp(obj, prop, functName, attr);
    }
  }
926731
function each (obj, fn) {
		const nth = obj.length;
		let i = -1;

		while (++i < nth) {
			if (fn.call(obj, obj[i], i) === false) {
				break;
			}
		}

		return obj;
	}
1125654
def evaluate_object(obj, cls=None, cache=False, **kwargs):
        """"""
        old_obj = obj
        if isinstance(obj, Element):
            if cache:
                obj = obj.evaluate_cached(**kwargs)
            else:
                obj = obj.evaluate(cache=cache, **kwargs)

        if cls is not None and type(obj) != cls:
            obj = cls(obj)

        for attr in ('string', 'location', 'tokens'):
            if hasattr(old_obj, attr):
                setattr(obj, attr, getattr(old_obj, attr))

        return obj
810264
function any(obj) {
  var ctx = this;

  if (typeof obj === 'function') {
    obj = slice.call(arguments);
  }

  return function(done) {
    var keys = Object.keys(obj);
    var isArray = Array.isArray(obj);
    var finished;

    function getkey(key) {
      return isArray ? Number(key) : key;
    }

    if (!keys.length) {
      setImmediate(function() {
        done(null, null);
      });
      return;
    }

    for (var i = 0; i < keys.length; i++) {
      run(obj[keys[i]], keys[i]);
    }

    function run(fn, key) {
      if (finished) return;
      try {
        fn = toThunk(fn, ctx);
        if (typeof fn !== 'function') {
          done(new Error('co.any only accept yieldables'));
        }
        fn.call(ctx, function(err, res) {
          if (finished) return;
          finished = true;
          if (err) {
            err._key = getkey(key);
            return done(err);
          }
          done(null, {
            _key: getkey(key),
            value: res
          });
        });
      } catch (err) {
        finished = true;
        err._key = getkey(key);
        done(err);
      }
    }
  }
}
407672
def eval_objfn(self):
        

        fval = self.obfn_f(self.X)
        gval = self.obfn_g(self.X)
        obj = fval + gval
        return (obj, fval, gval)
451334
function objectEach(obj, fn, thisObj) {
  var keys = Object.keys(obj).sort(function (a,b) {
    a = a.toLowerCase()
    b = b.toLowerCase()
    return a === b ? 0 : a < b ? -1 : 1
  })
  for (var i = 0, l = keys.length; i < l; i++) {
    var key = keys[i]
    fn.call(thisObj, obj[key], key, obj)
  }
}
1116911
function array(obj, fn, ctx) {
  for (var i = 0; i < obj.length; ++i) {
    fn.call(ctx, obj[i], i);
  }
}
674038
function portable(obj, fn)
	{
		if (typeof fn === 'string')
			fn = obj[fn];

		return function()
		{
			return fn.apply(obj, arguments);
		};
	}
594607
function(o,value,fn){
       this.forEach(o,function everymover(e,i,b){
         if(e === value){ 
          if(fn) fn.call(this,e,i,b);
        }
      },this);
       return;
    }
382598
function any(target, fn) {
  var keys = Object.keys(target);
  for(var i = 0, len = keys.length; i < len; i++) {
    var key = keys[i];
    var value = target[key];
    if(fn(value, key)) return true;
  }
  return false;
}