Note: information on this page refers to Ceylon 1.1, not to the current release.

Callable references

A callable reference is an expression that references something (a function, method, or class) that can be invoked by specifying a positional argument list.


value classReference = String;
value methodReference =;
value functionReference = sum<Integer>;


Callable references introduce a level of indirection between the definition of a function, method, or class, and the invocation of the function, method, or class, allowing the definition of generic functions, called higher order functions, that operate upon callable references and other Callable values.


The type of a callable reference is the callable type of the thing being referenced, so referring to the example above,

  • the type of classReference is String({Character*}),
  • the type of methodReference is Integer(Integer).
  • the type of functionReference is Integer({Integer+}),

Unreferenceable things

It's not possible to obtain a callable reference to an abstract class, because calling it would be the same as instantiating the abstract class. So, for example, the following code is illegal:

value objectReference = Object;

A callable reference to a generic declaration must specify type arguments, as shown by functionReference in the example above. This code is illegal:

value functionReference = sum;


A callable reference may be invoked, for example:

classReference({'h', 'e', 'l', 'l', 'o'})

This is an indirect invocation, so you cannot use a named argument list.


Callable does not refine Object.equals. This means that if you obtain two different callable references to the same thing they will not compare as equal:

value ref = String;
// while this assertion will pass...
assert(ref == ref);
// ...these assertions will fail
assert(String == String);
assert(ref == String);

While this may seem surprising for callable references like String it would also be surprising if some Callable instances had a semantic for equals, but others (such as those produced by higher order functions) did not.

See also