A function call as a term, as in {@code WHERE k = f(arguments)}.
483657
@NonNull
  public static Term function(
      @NonNull CqlIdentifier functionId, @NonNull Iterable<Term> arguments) {
    return function(null, functionId, arguments);
  }
525688
public ImmutableTerm convertIntoImmutableTerm(Term term) {
        if (term instanceof Function) {
            if (term instanceof Expression) {
                Expression expression = (Expression) term;
                return termFactory.getImmutableExpression(expression);
            } else {
                Function functionalTerm = (Function) term;

                if (functionalTerm.getFunctionSymbol() instanceof FunctionSymbol)
                    return termFactory.getImmutableFunctionalTerm(
                            (FunctionSymbol) functionalTerm.getFunctionSymbol(),
                            convertTerms(functionalTerm));
                else
                    throw new NotAFunctionSymbolException(term + " is not using a FunctionSymbol but a "
                            + functionalTerm.getFunctionSymbol().getClass());
            }
        }
        /*
         * Other terms (constant and variable) are immutable.
         */
        return (ImmutableTerm) term;
    }
44410
def CallUDFUNS(f, x):
    
    value = c_double()
    f(x, byref(value))
    return value.value
167423
public static <T> RelationalFunctionCall<T> relationalFunctionCall(Class<? extends T> type, String function, Object... args) {
        return new RelationalFunctionCall<T>(type, function, args);
    }
871637
def call(self, func, *args, **kwargs):
        
        wrapped = self.wrap(func)
        return wrapped(*args, **kwargs)
888754
function(funcName, expr, sup, sub) {
                    this.callBase();
                    this.setFlag("Func");
                    this.funcName = funcName;
                    this.setOperator(new FunctionOperator(funcName));
                    this.setExpr(expr);
                    this.setSuperscript(sup);
                    this.setSubscript(sub);
                }
679239
private void visitArgumentList(Node call, FunctionType functionType) {
    Iterator<Node> parameters = functionType.getParameters().iterator();
    Iterator<Node> arguments = NodeUtil.getInvocationArgsAsIterable(call).iterator();
    checkArgumentsMatchParameters(call, functionType, arguments, parameters, 0);
  }
77469
@Override
  public <O extends KbObject> O findOrCreateFunctionalTerm(Class<O> retType, Object... args) 
          throws KbTypeException, CreateException {
    return wrapped().findOrCreateFunctionalTerm(retType, args);
  }
349272
function maybeCall ( thing, ctx, args ) {
     return typeof thing == 'function' ? thing.apply(ctx, args) : thing
   }
147290
def auto_kwargs(function):
    """"""
    supported = introspect.arguments(function)

    @wraps(function)
    def call_function(*args, **kwargs):
        return function(*args, **{key: value for key, value in kwargs.items() if key in supported})
    return call_function
1018375
public void create_function( String name, int nargs, Function f ) {
        synchronized (this) {
            _create_function(name, nargs, f);
        }
    }
942811
def _call(self, func, out=None, **kwargs):
        """"""
        mesh = self.grid.meshgrid
        if out is None:
            out = func(mesh, **kwargs)
        else:
            with writable_array(out) as out_arr:
                func(mesh, out=out_arr, **kwargs)
        return out
291465
def call(func, args):
    
    assert hasattr(func, '__call__'), 'Cannot call func: {}'.format(
        func.__name__)
    raw_func = (
        func if isinstance(func, FunctionType) else func.__class__.__call__)
    hints = collections.defaultdict(lambda: Any, get_type_hints(raw_func))
    argspec = _getargspec(raw_func)
    named_args = {}
    varargs = ()
    for k, nk, v in _normalize(args):
        if nk == argspec.varargs:
            hints[nk] = Tuple[hints[nk], ...]
        elif nk not in argspec.args and argspec.varkw in hints:
            hints[nk] = hints[argspec.varkw]
        try:
            value = cast(hints[nk], v)
        except TypeError as e:
            _LOGGER.exception(e)
            six.raise_from(exc.InvalidCliValueError(k, v), e)
        if nk == argspec.varargs:
            varargs = value
        elif (nk in argspec.args or argspec.varkw) and (
                nk not in named_args or named_args[nk] is None):
            named_args[nk] = value
    return func(*varargs, **named_args)
1288398
protected Expression functionCall() {
        FunctionCall call = new FunctionCall();
        Token funToken = tokenizer.consume();
        Function fun = functionTable.get(funToken.getContents());
        if (fun == null) {
            errors.add(ParseError.error(funToken, String.format("Unknown function: '%s'", funToken.getContents())));
        }
        call.setFunction(fun);
        tokenizer.consume();
        while (!tokenizer.current().isSymbol(")") && tokenizer.current().isNotEnd()) {
            if (!call.getParameters().isEmpty()) {
                expect(Token.TokenType.SYMBOL, ",");
            }
            call.addParameter(expression());
        }
        expect(Token.TokenType.SYMBOL, ")");
        if (fun == null) {
            return Constant.EMPTY;
        }
        if (call.getParameters().size() != fun.getNumberOfArguments() && fun.getNumberOfArguments() >= 0) {
            errors.add(ParseError.error(funToken,
                                        String.format(
                                                "Number of arguments for function '%s' do not match. Expected: %d, Found: %d",
                                                funToken.getContents(),
                                                fun.getNumberOfArguments(),
                                                call.getParameters().size())));
            return Constant.EMPTY;
        }
        return call;
    }
458507
public static FuncN<Void> fromAction(final Action0 f) {
        return new FuncN<Void>() {

            @Override
            public Void call(Object... args) {
                if (args.length != 0) {
                    throw new RuntimeException("Action0 expecting 0 arguments.");
                }
                f.call();
                return null;
            }

        };
    }
972828
public static void mixin(final String funcName, final Function<String, String> func) {
        FUNCTIONS.put(funcName, func);
    }
1072894
function(f,c){
  var fn=f;
  var cn=c;
  return function(){
    fn.apply(cn,Array.prototype.slice.call(arguments));
  };
}