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());
}