Satisfied Interfaces: Annotated, AnnotatedDeclaration, Declaration, FunctionOrValueDeclaration, FunctionalDeclaration, GenericDeclaration, NestableDeclaration, TypedDeclaration

A function declaration.

### Usage sample for toplevel function

Because some functions have type parameters, getting a model requires applying type arguments to the function declaration with apply in order to be able to invoke that function. For example, here is how you would obtain a function model that you can invoke from a toplevel function declaration:

    String foo<T>(){
        return "Hello, our T is: ``typeLiteral<T>()``";
    }

    void test(){
        // We need to apply the Integer closed type to the foo declaration in order to get the foo<Integer> function model
        Function<String,[]> functionModel = `function foo`.apply<String,[]>(`Integer`);
        // This will print: Hello, our T is: ceylon.language::Integer
        print(functionModel());
    }

### Usage sample for methods

For methods it is a bit longer, because methods need to be applied not only their type arguments but also the containing type, so you should use memberApply and start by giving the containing closed type:

    class Outer(){
        shared String hello() => "Hello";
    }

    void test(){
        // apply the containing closed type `Outer` to the method declaration `Outer.hello`
        Method<Outer,String,[]> methodModel = `function Outer.hello`.memberApply<Outer,String,[]>(`Outer`);
        // We now have a Method, which needs to be applied to a containing instance in order to become an
        // invokable function:
        Function<String,[]> boundMethodModel = methodModel(Outer());
        // This will print: Hello
        print(boundMethodModel());
    }

Inherited Attributes
Attributes inherited from: Object hash, string
Attributes inherited from: Declaration name, qualifiedName
Attributes inherited from: FunctionOrValueDeclaration defaulted, parameter, variadic
Attributes inherited from: FunctionalDeclaration annotation, parameterDeclarations
Attributes inherited from: GenericDeclaration typeParameterDeclarations
Attributes inherited from: NestableDeclaration actual, container, containingModule, containingPackage, default, formal, shared, toplevel
Attributes inherited from: TypedDeclaration openType

Methods
apply | Source Code shared formal Function<Return,Arguments> apply<Return = Anything, Arguments = Nothing>(Type<Anything>[] typeArguments) given Arguments satisfies Anything[] Applies the given closed type arguments to this function declaration in order to obtain a function model. See this code sample for an example on how to use this. Throws: IncompatibleTypeException If the specified `Return` or `Arguments` type arguments are not compatible with the actual result. TypeApplicationException If the specified closed type argument values are not compatible with the actual result's type parameters.
invoke | Source Code shared default Anything invoke(Type<Anything>[] typeArguments = [], Anything[] arguments) Invokes the underlying toplevel function, by applying the specified type arguments and value arguments. Parameters: typeArguments = [] Throws: IncompatibleTypeException If the specified type or value arguments are not compatible with this toplevel function.
memberApply | Source Code shared formal Method<Container,Return,Arguments> memberApply<Container = Nothing, Return = Anything, Arguments = Nothing>(Type<Container> containerType, Type<Anything>[] typeArguments) given Arguments satisfies Anything[] Applies the given closed container type and type arguments to this method declaration in order to obtain a method model. See this code sample for an example on how to use this. Throws: IncompatibleTypeException If the specified `Container`, `Return` or `Arguments` type arguments are not compatible with the actual result. TypeApplicationException If the specified closed container type or type argument values are not compatible with the actual result's container type or type parameters.
memberInvoke | Source Code shared default Anything memberInvoke(Object container, Type<Anything>[] typeArguments = [], Anything[] arguments) Invokes the underlying method, by applying the specified type arguments and value arguments. Parameters: typeArguments = [] Throws: IncompatibleTypeException If the specified container, type or value arguments are not compatible with this method.

Inherited Methods
Methods inherited from: Object equals
Methods inherited from: AnnotatedDeclaration annotations
Methods inherited from: FunctionalDeclaration getParameterDeclaration
Methods inherited from: GenericDeclaration getTypeParameterDeclaration