Helpers requiring this closure
175450
function patchUser(user, patchToUser) {
      return users.patch(user.id || user._id, patchToUser, {}) // needs users from closure
        .then(() => Object.assign(user, patchToUser));
    }
224902
def lazyfunc(func):
    
    closuremem_ = [{}]
    def wrapper(*args, **kwargs):
        mem = closuremem_[0]
        key = (repr(args), repr(kwargs))
        try:
            return mem[key]
        except KeyError:
            mem[key] = func(*args, **kwargs)
        return mem[key]
    return wrapper
118421
@Cmd
	public void onError(final Closure<Void> closure) {
		int errorCount = errors.size();
		if (errorCount > 0) {
			log.info(errorCount + " error" + (errorCount == 1 ? "" : "s") + " in list --> executing block");
			closure.call();
			log.info("Finished OnError block");
		} else {
			log.info("No errors in list --> skipping block");
		}
	}
1363095
private void validateClosurePrimitive(Node n, JSDocInfo info) {
    if (info == null || !info.hasClosurePrimitiveId()) {
      return;
    }

    if (!isJSDocOnFunctionNode(n, info)) {
      report(n, MISPLACED_ANNOTATION, "closurePrimitive", "must be on a function node");
    }
  }
152220
def require(self, lock, guard_func, *guard_args, **guard_kw):
        
        def decorator(f):
            @wraps(f)
            def wrapper(*args, **kw):
                if self.granted(lock):
                    self.msg('Granted {}'.format(lock))
                    return f(*args, **kw)
                if guard_func(*guard_args, **guard_kw) and self.acquire(lock):
                    return f(*args, **kw)
                return None
            return wrapper
        return decorator
526993
function (helpers) {
            Y.log('Importing helpers: ' + helpers, 'info', 'builder');
            helpers.forEach(function (imp) {
                if (!Y.Files.exists(imp) || Y.Files.exists(path.join(process.cwd(), imp))) {
                    imp = path.join(process.cwd(), imp);
                }
                var h = require(imp);
                Object.keys(h).forEach(function (name) {
                    Y.Handlebars.registerHelper(name, h[name]);
                });
            });
        }
1038270
function oncurlyclose(state, curly, suber) {
	curly.count--;
	if (suber.protostring && curly.count === curly.protocount) {
		suber.protostring = null;
	}
}
554014
function(){
			var helpersToCall = [].slice.call(arguments, 0, arguments.length - 2).map(function(name){
				return Handlebars.helpers[name];
			}),
				value = arguments[arguments.length - 2] || "";
				
			helpersToCall.forEach(function(helper){
				value = helper.call(Handlebars, value);
			});
			
			return value;
		}
859725
function wrapGetterFn(_ref) {
        var _ref2 = slicedToArray(_ref, 2),
            key = _ref2[0],
            originalFn = _ref2[1];

        var newFn = function newFn() {
            var innerFn = originalFn.apply(this, arguments);

            if (typeof innerFn !== 'function') {
                /* istanbul ignore next */
                throw 'The getter ' + key + ' does not return a function. Try using the \'mapGetter\' helper instead';
            }

            return innerFn(this.id);
        };

        return [key, newFn];
    }
338216
function reduce(callable $closure, $carry = null) {
        foreach($this->data as $val) {
            $carry = $closure($carry, $val);
        }
        
        return $carry;
    }
674679
function helperMissing() {
  const args = [].slice.call(arguments);
  const options = args.pop();
  throw new Error(`cannot resolve permalink variable: ":${options.name}"`);
}
737371
function scanDeps() {
  var provideMap = new ProvideMap_();
  var requireMap = new RequireMap_();
  scanFiles(relativeGlob('lib'), provideMap, requireMap);

  var closureRequire = new RequireMap_();
  var closureProvide = new ProvideMap_();
  var closurePath = config.CLOSURE_LIBRARY_PATH + '/closure/goog';
  scanFiles(relativeGlob(closurePath), closureProvide, closureRequire);

  var closureDeps =
      extractClosureDependencies(requireMap, closureRequire, closureProvide);

  var edges = requireMap.getTopoSortEntry(provideMap, closureProvide);
  var edgesClosure = closureRequire.getTopoSortEntry(
      closureProvide, closureProvide, closureDeps);

  var topoSorter = new Toposort();
  edges.forEach(function(entry) {
    topoSorter.add(entry.name, entry.depends);
  });
  var topoSorterClosure = new Toposort();
  edgesClosure.forEach(function(entry) {
    topoSorterClosure.add(entry.name, entry.depends);
  });

  var files = [pathMod.resolve(
      pathMod.join(config.CLOSURE_LIBRARY_PATH, 'closure/goog/base.js'))];
  files = files.concat(topoSorterClosure.sort().reverse());
  files = files.concat(topoSorter.sort().reverse());

  return files;
}
505922
function Closure (parent, listOfKeys, accessor) {
  "use strict";

  var closure = {};

  listOfKeys = listOfKeys || [];
  accessor   = accessor || function () {};
  
  parent && parent.__mixin__ && parent.__mixin__(closure);

  listOfKeys.forEach(function (key) {
    closure[key] = accessor.bind(null, key);
  });

  this.getValues = function () {
    var values = {};
    Object.keys(closure).forEach(function (key) {
      values[key] = closure[key]();
      if (values[key] === undefined) {
        values[key] = null;
      }
      if (typeof values[key] === 'function') {
        throw new Error('a closure variable must be serializable, so you cannot use a function');
      }
    });
    return values;
  }

  this.setValues = function (values) {
    Object.keys(values).forEach(function (key) {
      closure[key](values[key]);
    });
  }

  this.__mixin__ = function (object) {
    Object.keys(closure).forEach(function (key) {
      object[key] = closure[key];
    });
  }

}
941098
function onComplete (err) {
    if (err) {
      console.log('interpolation encountered an error: ', err)
      return callback(err)
    }
    // set is complete and create a queue drain function
    // however, a feed may not have any interpolated times, so
    // `isComplete` is set in case nothing is pushed to the queue
    isComplete = true
    updateQueue.drain = () => {
      console.log('interpolation completed successfully')
      callback(err)
    }
  }
905207
function Helpers(options) {
  this.config = {};

  for (var key in options || {}) {
    this.config[key] = options[key];
  }

  this.ancestor = [];
}
1334659
function(helpers, options) {
      if (typeof helpers === 'object') {
        this.visit('helper', helpers);
        return this;
      }

      if (lazy.isGlob(helpers)) {
        this.loader('helpers-glob', ['base-glob'], function (files) {
          return files.map(function (fp) {
            return require(path.resolve(fp));
          });
        });

        var res = this.compose('helpers-glob')(helpers, options);
        this.visit('helper', res);
        return this;
      }

      if (typeof helpers === 'string') {
        console.log('loading helpers from a string is not implemented yet.');
      }
      return this;
    }
549175
public Closure getClosure(String key) {
        if (closures != null && !closures.isEmpty()) {
            return closures.get(key);
        }
        return null;
    }