Visit an explicit receiver with 3 args
 (This is ~30% faster than calling the general method)
762697
def visit_this_3(receiver, thing, arg1, arg2, arg3)
    if method_name = @cache[thing.class]
      return receiver.send(method_name, thing, arg1, arg2, arg3)
    end
    visit_this(receiver, thing, [arg1, arg2, arg3])
  end
1246047
def call(self, fn, args, name='', cconv=None, tail=False, fastmath=()):
        
        inst = instructions.CallInstr(self.block, fn, args, name=name,
                                      cconv=cconv, tail=tail, fastmath=fastmath)
        self._insert(inst)
        return inst
231018
function callMiddleware(entry, middleware, callback) {
  var index = 0;

  function next(entry, acc) {
    var layer = middleware[index++];
    if (!layer) {
      return callback(entry, acc);
    }

    var accumulator = acc || {};
    layer(entry, accumulator, next);
  }

  next(entry);
}
607300
function readCall(walker, defaultArgs) {
    walker.goUntil();
    var result = readAccessor(walker);

    var args;
    if (walker.goUntil(40)) { // (
        args = [];

        while (!walker.goUntil(41)) { // )
            args.push(readTertiaryExpr(walker));
            walker.goUntil(44); // ,
        }
    }
    else if (defaultArgs) {
        args = defaultArgs;
    }

    if (args) {
        result = {
            type: ExprType.CALL,
            name: result,
            args: args
        };
    }

    return result;
}
103414
def _pulse_method_call(pulse_op, func=None, index_arg=True):
		''''''
		def _wrapper(self, *args, **kws):
			if index_arg:
				if 'index' in kws: index = kws.pop('index')
				else: index, args = args[0], args[1:]
			pulse_args = func(*args, **kws) if func else list()
			if not is_list(pulse_args): pulse_args = [pulse_args]
			if index_arg: pulse_args = [index] + list(pulse_args)
			with self._pulse_op_cb() as cb:
				try: pulse_op(self._ctx, *(list(pulse_args) + [cb, None]))
				except c.ArgumentError as err: raise TypeError(err.args)
				except c.pa.CallError as err: raise PulseOperationInvalid(err.args[-1])
		func_args = list(inspect.getargspec(func or (lambda: None)))
		func_args[0] = list(func_args[0])
		if index_arg: func_args[0] = ['index'] + func_args[0]
		_wrapper.__name__ = '...'
		_wrapper.__doc__ = 'Signature: func' + inspect.formatargspec(*func_args)
		if func.__doc__: _wrapper.__doc__ += '\n\n' + func.__doc__
		return _wrapper
25823
def use_args(
        self,
        argmap: ArgMap,
        req: typing.Optional[Request] = None,
        locations: typing.Iterable = None,
        as_kwargs: bool = False,
        validate: Validate = None,
        error_status_code: typing.Optional[int] = None,
        error_headers: typing.Union[typing.Mapping[str, str], None] = None,
    ) -> typing.Callable[..., typing.Callable]:
        
        locations = locations or self.locations
        request_obj = req
        # Optimization: If argmap is passed as a dictionary, we only need
        # to generate a Schema once
        if isinstance(argmap, Mapping):
            argmap = core.dict2schema(argmap, self.schema_class)()

        def decorator(func: typing.Callable) -> typing.Callable:
            req_ = request_obj

            if inspect.iscoroutinefunction(func):

                @functools.wraps(func)
                async def wrapper(*args, **kwargs):
                    req_obj = req_

                    if not req_obj:
                        req_obj = self.get_request_from_view_args(func, args, kwargs)
                    # NOTE: At this point, argmap may be a Schema, callable, or dict
                    parsed_args = await self.parse(
                        argmap,
                        req=req_obj,
                        locations=locations,
                        validate=validate,
                        error_status_code=error_status_code,
                        error_headers=error_headers,
                    )
                    if as_kwargs:
                        kwargs.update(parsed_args or {})
                        return await func(*args, **kwargs)
                    else:
                        # Add parsed_args after other positional arguments
                        new_args = args + (parsed_args,)
                        return await func(*new_args, **kwargs)

            else:

                @functools.wraps(func)  # type: ignore
                def wrapper(*args, **kwargs):
                    req_obj = req_

                    if not req_obj:
                        req_obj = self.get_request_from_view_args(func, args, kwargs)
                    # NOTE: At this point, argmap may be a Schema, callable, or dict
                    parsed_args = yield from self.parse(  # type: ignore
                        argmap,
                        req=req_obj,
                        locations=locations,
                        validate=validate,
                        error_status_code=error_status_code,
                        error_headers=error_headers,
                    )
                    if as_kwargs:
                        kwargs.update(parsed_args)
                        return func(*args, **kwargs)  # noqa: B901
                    else:
                        # Add parsed_args after other positional arguments
                        new_args = args + (parsed_args,)
                        return func(*new_args, **kwargs)

            return wrapper

        return decorator
1337495
public static void callMethod(final Object obj, final String methodName, final boolean includePrivateMehtods, final Object... args)
			throws InvocationTargetException {
		final Class[] intArgsClass = initParamsClasses(args);
		try {
			Class<?> current = obj.getClass();
			Method method = null;
			while (current != Object.class) {
				try {
					method = current.getDeclaredMethod(methodName, intArgsClass);
					break;
				} catch (final NoSuchMethodException ex) {
					current = current.getSuperclass();
				}
			}
			if (method == null) {
				throw new NoSuchMethodException("Mehtod is not found in " + current);
			}
			method.setAccessible(true);
			method.invoke(obj, args);
		} catch (final InvocationTargetException e) {
			throw new InvocationTargetException(e.getCause());
		} catch (final Exception e) {
			throw new InvocationTargetException(e);
		}
	}
845265
def _extcap_call(prog, args, keyword, values):
    """"""
    p = subprocess.Popen(
        [prog] + args,
        stdout=subprocess.PIPE, stderr=subprocess.PIPE
    )
    data, err = p.communicate()
    if p.returncode != 0:
        raise OSError("%s returned with error code %s: %s" % (prog,
                                                              p.returncode,
                                                              err))
    data = plain_str(data)
    res = []
    for ifa in data.split("\n"):
        ifa = ifa.strip()
        if not ifa.startswith(keyword):
            continue
        res.append(tuple([re.search(r"{%s=([^}]*)}" % val, ifa).group(1)
                   for val in values]))
    return res
393575
public Reflector call(String name, Object... args) throws ReflectException {
        Class<?>[] types = getTypes(args);

        try {
            Method method = exactMethod(name, types);
            return with(method, obj, args);
        } catch (NoSuchMethodException e) {
            try {
                Method method = similarMethod(name, types);
                return with(method, obj, args);
            } catch (NoSuchMethodException e1) {
                throw new ReflectException(e1);
            }
        }
    }
1305842
function trycatchit(tryFn, that, args) {
  try {
    // Avoid slow apply for common use
    switch(args ? args.length : 0) {
    case 0:
      tryFn.call(that)
      break
    case 1:
      tryFn.call(that, args[0])
      break
    case 2:
      tryFn.call(that, args[0], args[1])
      break
    case 3:
      tryFn.call(that, args[0], args[1], args[2])
      break
    case 4:
      tryFn.call(that, args[0], args[1], args[2], args[3])
      break
    case 5:
      tryFn.call(that, args[0], args[1], args[2], args[3], args[4])
      break
    case 6:
      tryFn.call(that, args[0], args[1], args[2], args[3], args[4], args[5])
      break
    case 7:
      tryFn.call(that, args[0], args[1], args[2], args[3], args[4], args[5], args[6])
      break
    case 8:
      tryFn.call(that, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7])
      break
    case 9:
      tryFn.call(that, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8])
      break
    default:
      tryFn.apply(that, args)
    }
  } catch(err) {
    return err
  }
}
361971
def nonraw_instance(receiver):
    
    @wraps(receiver)
    def wrapper(sender, instance, raw, using, **kwargs):
        if raw:
            instance = sender._default_manager.using(using).get(pk=instance.pk)
        return receiver(sender=sender, raw=raw, instance=instance, using=using,
                        **kwargs)
    return wrapper
749172
function Debounce(delay=300, options={leading: true, trailing: false}) {
    let d = (methodDescriptor, args)=>{
        let {descriptor} = methodDescriptor;

        let fn = descriptor.value;
        descriptor.value = debounce(fn, ...args);

        return {
            ...methodDescriptor,
            descriptor,
        };
    };

    if (typeof delay === 'object') {
        d(delay, [300, {leading: true, trailing: false}]);
    } else {
        return (m)=>d(m, [delay, options]);
    }
}
952364
public static void callMethod(final Object obj, final String methodName, final Object... args) {
		try {
			callMethod(obj, methodName, false, args);
		} catch (InvocationTargetException e) {
			JK.throww(e);
		}
	}
688005
def call(target, *args, &block)
      case object
      when Symbol
        target.public_send(object.to_sym, *args, &block)
      when String
        string = args.empty? ? "-> { #{object} }" : "-> { #{object}(*#{args}) }"
        value  = eval(string)
        target.instance_exec(&value)
      when ::Proc
        object.arity.zero? ? object.call : object.call(target, *args)
      else
        raise ArgumentError, "Unknown callable #{object}"
      end
    end
944663
function triggerEvents (list, args, context) {
  var pass = true

  if (list) {
    var i = 0
    var l = list.length
    var a1 = args[0]
    var a2 = args[1]
    var a3 = args[2]
    // call is faster than apply, optimize less than 3 argu
    // http://blog.csdn.net/zhengyinhui100/article/details/7837127
    switch (args.length) {
      case 0: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context) !== false && pass} break
      case 1: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context, a1) !== false && pass} break
      case 2: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context, a1, a2) !== false && pass} break
      case 3: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context, a1, a2, a3) !== false && pass} break
      default: for (; i < l; i += 2) {pass = list[i].apply(list[i + 1] || context, args) !== false && pass} break
    }
  }
  // trigger will return false if one of the callbacks return false
  return pass
}
454176
def call(__self, __context, __obj, *args, **kwargs):
        """"""
        fmt = inspect_format_method(__obj)
        if fmt is not None:
            return __self.format_string(fmt, args, kwargs)

        # the double prefixes are to avoid double keyword argument
        # errors when proxying the call.
        if not __self.is_safe_callable(__obj):
            raise SecurityError('%r is not safely callable' % (__obj,))
        return __context.call(__obj, *args, **kwargs)
196874
function ConvertArgs(args, baseResponse) {
    var baseResponse = Object.assign({}, baseResponse);
    args.forEach(function(arg, i) {
        if (typeof(arg) == "object" && arg._classname == "SerializedFunction") {
            var idRemoteFunction = arg.id;
            args[i] = function() {
                process.send(Object.assign(baseResponse, {name: "thread-execute-remote-function", args: [{id: idRemoteFunction, args: SerializeForProcess(CopyArguments(arguments))}]}));
            };
        }
    });
    return args;
}