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

Type abbreviations

Some types are so commonly used in Ceylon that there are special abbreviations for them.


Here are some examples:

T?          // T|Null
{T*}        // Iterable<T,Null>
{T+}        // Iterable<T,Nothing>, has at least one element
[T*] or T[] // Sequential<T>
[]          // Empty
[T+]        // Sequence<T>
X->Y        // Entry<X,Y>

Certain abbreviations have a recursive definition, so we can't enumerate all the possibilities here.

There are abbreviations for tuple types:

[T]         // The 1-tuple Tuple<T, T, Empty>
[X,Y]       // The 2-tuple Tuple<X|Y, X, Tuple<Y, Y, Empty>>
            // whose first element is an X and whose 
            // second element is a Y
[X,Y*]      // The *-tuple Tuple<X|Y, X, Sequential<Y>>
            // whose first element is an X and 
            // which has zero or more further elements 
            // each of type Y
[X,Y+]      // The +-tuple Tuple<X|Y, X, Sequence<Y>>
            // whose first element is an X and 
            // which has one or more further elements 
            // each of type Y

And for function types:

R()         // Callable<R,[]>, function with no parameters
R(P1,P2)    // Callable<R,[P1,P2]>, function with two parameters
R(P1,P2=)   // Callable<R,[P1]|[P1,P2]>, function with defaulted param
R(P*)       // Callable<R,[P1*]>, variadic function
R(P+)       // Callable<R,[P1+]>, nonempty variadic function


The above abbreviations can be used anywhere a type is expected.


The type abbtreviation R(P1,P2) is the same as Callable<R,[P1,P2]>, which is the type of a function which takes parameters of types P1 and P2 and returns an R. R(P1,P2) may also be the type of the class R if its initializer takes parameters of types P1 and P2.

For higher order Callables, there is the potential for some confusion. Consider the following abbreviated Callable type:


This is the type of the function:

Bar higher(Foo)(String) {
    // ...

Notice how the String and Foo swapped places?

If you think about it, higher could be declared like this:

Bar(String) higher2(Foo) {
    // ...

And when you write it that way, it's not really surprising that higher2 itself has type Bar(String)(Foo).

Variadic parameters

Although not technically a type abbreviation, variadic parameters are declared using a syntax that looks similar to the Callable, Iterable, and Tuple abbreviations above:

T*        // a possibly empty variadic parameter
T+        // a non-empty variadic parameter

Of course, it's no coincidence that the function Float sum(Float+ floats) has the function type Float(Float+).

See Also