Overload: no function.
430717
def asynciotask(
    func: None = None,
    *,
    loop_getter: typing.Union[
        typing.Callable[..., asyncio.AbstractEventLoop], asyncio.AbstractEventLoop
    ] = asyncio.get_event_loop,
    loop_getter_need_context: bool = False,
) -> AsyncIOTask:
    """"""
885917
function (fn) {
    if (!fn || !_.isFunction(fn)) {
      var err = new Error('Please pass a valid function!');
      debug(err);
      throw err;
    }

    this.structureLoader = customLoader(fn);

    return this;
  }
80752
function nothing () {
	var params = new Parameterizer (null, null);
	params.get = function (ignore) {
		return undefined;
	};
	return params;
}
1306758
function(value, attr, fn, model, computed, indices) {
        return fn.call(this, value, attr, model, computed, indices);
      }
1275201
def iter(self, count=0):
        '''
        '''
        while True:
            yield super(FuncRoll, self).roll(count, self._func)
411471
def no_operation(self, onerror = None):
        """"""
        request.NoOperation(display = self.display,
                            onerror = onerror)
316597
def load(cls, serialised):
        """"""
        pipeline = cls()
        for fn_name in serialised:
            try:
                fn = cls.registered_functions[fn_name]
            except KeyError:
                raise BaseLunrException(
                    "Cannot load unregistered function ".format(fn_name)
                )
            else:
                pipeline.add(fn)

        return pipeline
301839
function unload(inst, list, argv, event, fin) {
    inst.counter++;
    if (inst.options.debug) Console.printDebug(inst, list);
    if (_isQuote(list)) {
        return quote(inst, list, argv, event, fin);
    }
    if (_isFunc(list)) {
        if (_callReady(list)) {
            return invoke(inst, list, argv, event, fin);
        }
    }
    return sequence(inst, list, argv, event, fin);
}
478855
function isNotFunction(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && typeof value === 'function') {
        throw TypeException.unexpectedType(assertionTypes.IS_NOT_FUNCTION, value, '<function>', message, id);
    }
}
734674
def add_event(self, func: Callable, event: str) -> None:
        
        self._events[event].add(func)
696712
function(inXhr) {
		if (inXhr.onload) {
			inXhr.onload = null;
		}
		if (inXhr.onreadystatechange) {
			inXhr.onreadystatechange = null;
		}
		if (inXhr.abort) {
			inXhr.abort();
		}
	}
1051641
function(load) {
			var value, loading, handles = [],
				h;
			return function(handle) {
				if(!loading) {
					loading = true;
					load(function(v) {
						value = v;
						while(h = handles.shift()) {
							try {
								h && h.apply(null, [value]);
							} catch(e) {
								setTimeout(function() {
									throw e;
								}, 0)
							}
						}
					})
				}
				if(value) {
					handle && handle.apply(null, [value]);
					return value;
				}
				handle && handles.push(handle);
				return value;
			}
		}
235759
function (events) {
        "use strict";
    
        requirejs.onError = function (err) {
    
            if (err.requireType === 'timeout') {
    
                events.trigger('error');
                for (var i in err.requireModules) {
                    requirejs.undef(err.requireModules[i]);
                }
    
                // try again loading modules
                require(err.requireModules, function () {
                    events.trigger('retried');
                });
    
            }
            else {
                console.log(err.stack);
            }
    
        };
    
    }
790620
function(v, i) {
      if (v === undefined || v === null) return;
      failed += !iterator.call(context, v, type, level, i);
    }
1043838
func (h *health) overloaded() {
	timeout := time.Duration(5 * time.Second)
	client := http.Client{
		Timeout: timeout,
	}
	url := "http://" + h.Addr
	tick := time.NewTicker(1 * time.Second)

	for {
		select {
		case <-tick.C:
			start := time.Now()
			resp, err := client.Get(url)
			if err != nil {
				HealthDuration.Observe(timeout.Seconds())
				continue
			}
			resp.Body.Close()
			HealthDuration.Observe(time.Since(start).Seconds())

		case <-h.stop:
			tick.Stop()
			return
		}
	}
}
334460
function function_ (options) {
  options.hash.kind = 'function'
  var result = ddata._identifier(options)
  return result ? options.fn(result) : 'ERROR, Cannot find function.'
}
303479
function Overload() {
		if (arguments.length == 0) {
			throw new ERR.Arguments('1+', 0);
		}
		var args = Array.from(arguments);

		var method = args.pop();
		if (typeof method == 'function') {
			this.method = method;
		}
		else {
			throw new ERR.Generic('overloading implementation function missed');
		}

		// 支持可变长度参数后，用于代表值组长度的数字，也可以用 Param 实例来表征。
		// 在此我们仍保留 argLength，是出于提高性能的考虑。
		if (typeof args[0] == 'number' && args.length == 1) {
			// if (args.length > 1) {
			// 	throw new ERR.Arguments(2, args.length + 1);
			// }
			this.argLength = args[0];
		}
		else if (args[0] instanceof ParamList) {
			if (args.length > 1) {
				throw new ERR.Arguments(2, args.length + 1);
			}
			this.params = args[0];
		}
		else {
			this.params = ParamList.parse.apply(null, args);
		}
	}