# Type abbreviations

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

## Usage

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>>
[X,Y*]      // The *-tuple Tuple<X|Y, X, Sequential<Y>>
[X,Y+]      // The +-tuple Tuple<X|Y, X, Sequence<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+]>, nonempty variadic function

## Description

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

### Callable

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:

Bar(String)(Foo)

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).