A reference to a function. The type arguments encode the Return of the function along with its Arguments. The parameter types are represented by a tuple type. Functions declared `void` are considered to have the return type `Anything`.

For example, the type of the anonymous function `(Float x, Integer y) => x^y+1` is:

    Callable<Float, [Float,Integer]>

which we usually abbreviate to `Float(Float,Integer)`.

Likewise, the type of the function reference `plus<Float>` to the function `plus()` is:

    Callable<Float, [Float,Float]>

which we abbreviate as `Float(Float,Float)`.

A variadic function is represented using an unterminated tuple type. For example, the type of the function reference `concatenate<Object>` to the function `concatenate()` is:

    Callable<Object[], [{Object*}*]>

which we usually abbreviate `Object({Object*}*)`.

A function with defaulted parameters is represented using a union type. For example, the type of the method reference `process.writeLine` to the method `process.writeLine()` is:

    Callable<Anything, [String]|[]>

which we usually abbreviate `Anything(String=)`.

Any instance of `Callable` may be invoked by supplying a positional argument list:

    Float(Float,Float) add = plus<Float>;
    value four = add(2.0, 2.0);

or by supplying a tuple containing the arguments:

    Float(Float,Float) add = plus<Float>;
    [Float,Float] twoAndTwo = [2.0, 2.0];
    value four = add(*twoAndTwo);

The type of the tuple must be assignable to the type argument of `Arguments`.

This interface may not be implemented by user code.

See also `Tuple`

no type hierarchy

no supertypes hierarchy

- `Callable`
  - `Class`
  - `Function`
  - `Member`
    - `Attribute`
    - `MemberClass`
    - `MemberInterface`
    - `Method`

Inherited Attributes
Attributes inherited from: `Object` `Object.hash`, `Object.string`

Inherited Methods
Methods inherited from: `Object` `Object.equals()`