# Index

`AbstractAnnotation` | The annotation class for the `abstract()` annotation.
`ActualAnnotation` | The annotation class for the `actual()` annotation.
`AliasDeclaration` | Type alias declaration.
`AliasesAnnotation` | The annotation class for the `aliased()` annotation.
`Annotated` | A program element that can be annotated.
`AnnotatedDeclaration` | Declaration which can be annotated, such as: `NestableDeclaration` `Module` `Package` You can query…
`Annotation` | The supertype of all annotation classes. ### Annotation classes An annotation class must satisfy `Annotation`, […
`AnnotationAnnotation` | The annotation class for the `annotation()` meta-annotation.
`Anything` | The abstract supertype of all types.
`Applicable` | Represents classes or functions that you can apply in a type-unsafe way.
`Array` | A fixed-sized array of mutable elements.
`ArraySequence` | A `Sequence` backed by an `Array`.
`AssertionError` | An error that occurs due to an incorrectly written program.
`Attribute` | An attribute model represents the model of a Ceylon attribute that you can read and inspect.
`AuthorsAnnotation` | The annotation class for the `by()` annotation.
`Basic` | The default superclass when no superclass is explicitly specified using `extends`.
`Binary` | Abstraction of types that are conceptually a sequence of bits, and may be the subject of bitwise operations.
`Boolean` | A type capable of representing the values `true` and `false` of Boolean logic.
`Byte` | An 8-bit byte.
`Callable` | A reference to a function.
`CallableConstructor` | A callable constructor model represents the model of a Ceylon class constructor that you can invoke and inspect ## …
`CallableConstructorDeclaration` | Declaration model for callable constructors, for example
    class WithConstructors {
        shared new () {}…
`Category` | Abstract supertype of objects that contain other values, called elements, where it is possible to efficiently…
`Character` | A 32-bit [Unicode][] character.
`Class` | A class model represents the model of a Ceylon class that you can instantiate and inspect.
`ClassDeclaration` | Class declaration. ### Callable classes Since Ceylon 1.2 classes are not always directly invokable (if the class has…
`ClassModel` | A class model represents the model of a Ceylon class that you can inspect.
`ClassOrInterface` | Model of a class or interface that you can inspect.
`ClassOrInterfaceDeclaration` | A class or interface declaration.
`ClassWithConstructorsDeclaration` | The declaration model of a class that has constructors.
`ClassWithInitializerDeclaration` | The declaration model of a class that has a parameter list rather than explicit constructors.
`Collection` | An iterable collection of elements of finite `Iterable.size`, with a well-defined notion of value equality.
`Comparable` | The general contract for values whose magnitude can be compared.
`Comparison` | The result of a comparison between two `Comparable` objects: `larger`, `smaller`, or `equal`.
`ConstrainedAnnotation` | An annotation constrained to appear only on certain program elements, and only with certain values.
`ConstructorDeclaration` | Abstraction over callable constructors and [[value constructors|…
`Contextual` | Stores values local to the current thread of execution meaning that each thread or process that accesses these values…
`Correspondence` | Abstract supertype of objects which associate values with keys.
`Declaration` | A declaration.
`Declared` | A model element that has a declaration.
`DefaultAnnotation` | The annotation class for the `default()` annotation.
`DeprecationAnnotation` | The annotation class for the `deprecated()` annotation.
`DeserializationContext` | A contract for identifying instances, specifying their classes, attributes, elements and values, and ultimately…
`DeserializationException` | Thrown to indicate an exception event during deserialization
`Destroyable` | Abstract supertype of resources which are created at the beginning of a `try` statement and destroyed when the…
`DocAnnotation` | The annotation class for the `doc()` annotation.
`Element` | An `Array` instance referring to another instance via one of its elements.
`Empty` | A sequence with no elements.
`Entry` | A pair containing a key and an associated value called the item.
`Enumerable` | Abstraction of ordinal types whose values may be used as endpoints of a `span()` or `measure()`.
`Exception` | The supertype of all unexpected transient failures.
`Exponentiable` | Abstraction of numeric types that may be raised to a power using the exponentiation operator `x ^ n`…
`FinalAnnotation` | The annotation class for the `final()` annotation.
`Finished` | The type of the value that indicates that an `Iterator` is exhausted and has no more values to return.
`Float` | An IEEE 754 64-bit [floating point number][].
`FormalAnnotation` | The annotation class for the `formal()` annotation.
`Function` | A function model represents the model of a Ceylon function that you can invoke and inspect.
`FunctionDeclaration` | Abstraction over declarations which can be invoked, namely functions, methods and constructors
`FunctionModel` | A function model represents the model of a Ceylon function that you can inspect.
`FunctionOrValueDeclaration` | A function or value declaration.
`Functional` | Abstraction for models which have a parameter list.
`FunctionalDeclaration` | A function declaration.
`Generic` | A generic model which has closed type arguments.
`GenericDeclaration` | A declaration that can have type parameters.
`Gettable` | An abstraction of things that have a value which be got, and possibley set.
`GettableDeclaration` | Abstraction over declarations from which a value can be obtained, namely `ValueDeclaration` which abstracts over…
`Identifiable` | The abstract supertype of all types with a well-defined notion of identity.
`Import` | Model of an `import` declaration within a module declaration.
`IncompatibleTypeException` | Thrown when you invoke metamodel methods with invalid or incompatible type arguments.
`InitializationError` | Assertion failure that occurs when a value reference could not be initialized, including when: a…
`Integer` | An exact representation of a positive whole number, negative whole number, or zero.
`Integral` | Abstraction of integral numeric types.
`Interface` | An interface model that you can inspect.
`InterfaceDeclaration` | An interface declaration.
`InterfaceModel` | An interface model represents the model of a Ceylon interface that you can inspect.
`IntersectionType` | A closed intersection type.
`Invertible` | Abstraction of additive numeric types which support a unary operation `-x` producing the additive inverse…
`InvocationException` | Thrown when attempting to invoke something which can't be invoked, like abstract class initialisers.
`Iterable` | Abstract supertype of categories whose elements may be iterated.
`Iterator` | Produces the elements of an `Iterable` object.
`LateAnnotation` | The annotation class for the `late()` annotation.
`LicenseAnnotation` | The annotation class for the `license()` annotation.
`List` | A collection in which every element has a unique non-negative integer index.
`Map` | A collection which maps keys to items, where a key can map to at most one item.
`Member` | Model for members that can be bound to a containing instance to turn them into toplevel models.
`Member` | An instance referring to another instance via a reference attribute.
`MemberClass` | A class model represents the model of a Ceylon class that you can instantiate and inspect.
`MemberClassCallableConstructor` | A model for a callable constructor of a member class.
`MemberClassValueConstructor` | A model for a value constructor of a member class.
`MemberInterface` | A member interface model that you can inspect.
`Method` | A function model represents the model of a Ceylon function that you can invoke and inspect.
`Model` | The root of all models.
`Module` | A `module` declaration from a `module.ceylon` compilation unit
`MutationException` | Thrown when you try to change the value of a non-variable value
`NativeAnnotation` | The annotation class for the `native()` annotation.
`NestableDeclaration` | A declaration which can be contained in a `Package` or in another `NestableDeclaration`.
`Null` | The type of the `null` value.
`Number` | Abstraction of numeric types with a natural total order, including the built-in numeric…
`Numeric` | Abstraction of numeric types with the usual binary operations: addition, `x + y`, subtraction, `x - y`, -…
`Object` | The abstract supertype of all types representing definite values.
`Obtainable` | Abstract supertype of resources which may be obtained at the beginning of a `try` statement and then released when the…
`OpenClassOrInterfaceType` | An open class or interface, with open type arguments.
`OpenClassType` | An open class type.
`OpenInterfaceType` | An open interface type.
`OpenIntersection` | An open intersection type.
`OpenType` | An open type.
`OpenTypeArgument` | A tuple representing an open type argument and its use-site variance.
`OpenTypeVariable` | An open type variable.
`OpenUnion` | An open union type.
`OptionalAnnotation` | An annotation that may occur at most once at a given program element and only on certain program elements.
`OptionalImportAnnotation` | The annotation class for the `optional()` annotation.
`Ordinal` | Abstraction of ordinal types, that is, of types where each instance has a `Ordinal.successor` and `Ordinal.predecessor`, such…
`Outer` | A member instance referring to its outer instance.
`OverflowException` | Thrown when a mathematical operation caused a number to overflow from its bounds, or when a numeric narrowing…
`Package` | Model of a `package` declaration from a `package.ceylon` compilation unit
`Qualified` | Abstraction for models of elements which must be qualified by an instance to order to be evaluated, including: [[…
`Range` | A range of adjacent `Enumerable` values.
`Ranged` | Abstract supertype of ranged streams mapping a range of discrete indices to elements of the stream, and supporting…
`ReachableReference` | A means via which one instance can refer to another.
`References` | Exposes the instances directly reachable from a given instance.
`Resource` | A file packaged within a module.
`Scalable` | Abstract supertype of types that support scaling by a numeric factor.
`SealedAnnotation` | The annotation class for the `sealed()` annotation.
`SearchableList` | A `List` which can be efficiently searched for occurrences of a given element, or for inclusions of a given sublist…
`SeeAnnotation` | The annotation class for the `see()` annotation.
`Sequence` | A nonempty, immutable sequence of values.
`SequencedAnnotation` | An annotation that may occur multiple times at a given program element, and only on certain program elemenets.
`Sequential` | A possibly-empty, immutable sequence of values.
`SerializableAnnotation` | The annotation class for the `serializable()` annotation.
`SerializationContext` | A context representing serialization of many objects to a single output stream.
`SerializationException` | Thrown to indicate an exception event during serialization
`Set` | A collection in which each distinct element occurs at most once.
`SetterDeclaration` | A setter declaration represents the assign block of a `ValueDeclaration`.
`SharedAnnotation` | The annotation class for the `shared()` annotation.
`Singleton` | A `Sequence` with exactly one `Singleton.element`, which may be null.
`StorageException` | Thrown when you try to read attributes that were not shared nor captured and had no physical storage allocated, so do…
`String` | A string of characters.
`StringBuilder` | Builder utility for constructing strings by incrementally appending strings or characters.
`Summable` | Abstraction of types which support a binary addition operator `x + y`.
`SuppressWarningsAnnotation` | The annotation class for the `suppressWarnings()` annotation.
`TagsAnnotation` | The annotation class for the `tagged()` annotation.
`Throwable` | The abstract supertype of values indicating exceptional conditions.
`ThrownExceptionAnnotation` | The annotation class for the `throws()` annotation.
`Tuple` | A tuple is a typed linked list.
`Type` | A closed type.
`TypeApplicationException` | Thrown when declarations are applied with invalid or incompatible type arguments.
`TypeArgument` | A tuple representing a type argument and its use-site variance.
`TypeParameter` | A type parameter declaration.
`TypedDeclaration` | Declaration which has an open type.
`UninitializedLateValue` | The type of `uninitializedLateValue`.
`UnionType` | A closed union type.
`Usable` | Abstract supertype of resources whose lifecyle may be managed by the `try` statement.
`Value` | A value model represents the model of a Ceylon value that you can read and inspect.
`ValueConstructor` | A callable constructor model represents the model of a Ceylon class value constructor that you can get and inspect ## …
`ValueConstructorDeclaration` | Declaration model for value constructors, for example
    class Currency {
        "The US Dollar"
        shared new…
`ValueDeclaration` | A value declaration.
`ValueModel` | A value model represents the model of a Ceylon value that you can inspect.
`VariableAnnotation` | The annotation class for the `variable()` annotation.
`Variance` | Variance information.
`abstract()` | Annotation to mark a class as abstract.
`actual()` | Annotation to mark a member of a type as refining a member of a supertype.
`aliased()` | Annotation to specify a list of aliases that tools such as auto-completion and quick-fixes should consider, to help…
`and()` | Returns a function which is the logical conjunction of the given predicate functions.
`annotation()` | Annotation to mark a class as an annotation class, or a top-level function as an annotation constructor.
`annotations()` | The annotations of the given type applied to the given program element.
`any()` | Determines if any one of the given boolean values (usually a comprehension) is `true`.
`anyPair()` | Given two streams, return `true` if some pair of elements in the given streams satisfies the given binary [[predicate…
`apply()` | Applies an arbitrary `Return(*Arguments)` to the given arguments.
`arrayOfSize()` | Create an array of the specified `size`, populating every index with the given `element`.
`by()` | Annotation to document the authors of an API.
`byDecreasing()` | Produces a comparator function which orders elements in decreasing order according to the `Comparable` value…
`byIncreasing()` | Produces a comparator function which orders elements in increasing order according to the `Comparable` value…
`byItem()` | A comparator for `Entry`s which compares their items according to the given `comparing()` function.
`byKey()` | A comparator for `Entry`s which compares their keys according to the given `comparing()` function.
`classDeclaration()` | Returns the class declaration for a given instance.
`className()` | Return the name of the concrete class of the given object, in a format native to the virtual machine.
`comparing()` | A single comparator function which delegates to each of the given comparator functions in turn,…
`compose()` | Given a function with return type `Y`, and a second function with a single parameter also of type `Y`, return the…
`concatenate()` | Given zero or more argument streams, return a new sequence containing all elements of every given stream…
`contravariant` | Contravariant means that supertypes of the given type may be accepted.
`corresponding()` | Compares corresponding elements of the given streams using the given binary predicate function.
`count()` | A count of the number of `true` items in the given values.
`covariant` | Covariant means that subtypes of the given type may be returned.
`curry()` | Curries a function, returning a function with two parameter lists, given a function with at least one parameter.
`decreasing()` | A comparator function which orders elements in decreasing natural order.
`decreasingItem()` | A comparator function which orders entries by decreasing natural order of their [[items|…
`decreasingKey()` | A comparator function which orders entries by decreasing natural order of their [[keys|…
`default()` | Annotation to mark a member whose implementation may be refined by subtypes.
`deprecated()` | Annotation to mark program elements which should not be used anymore.
`deserialization()` | A new `DeserializationContext`.
`doc()` | Annotation to specify API documentation of a program element.
`empty` | A sequence with no elements, abbreviated `[]`.
`emptyIterator` | An iterator that returns no elements.
`emptyMap` | An immutable `Map` with no entries.
`emptyOrSingleton()` | A singleton `Tuple` with the given `element` if the given element is non-null, or the empty sequence…
`emptySet` | An immutable `Set` with no elements.
`equal` | The value is exactly equal to the given value.
`every()` | Determines if every one of the given boolean values (usually a comprehension) is `true`.
`everyPair()` | Given two streams, return `true` if every pair of elements in the given streams satisfies the given binary [[predicate…
`expand()` | Given a stream whose elements are also streams, return a new stream with all elements of every nested…
`false` | A value representing falsity in Boolean logic.
`final()` | Annotation to mark a class as final.
`findPair()` | Given two streams, return the first pair of elements in the given streams that satisfies the given binary [[predicate…
`finished` | A value that indicates that an `Iterator` is exhausted and has no more values to return.
`flatten()` | Given a function with a single parameter of tuple type `[P1, P2, ..., Pn]`, return a function with multiple…
`foldPairs()` | Given two streams, return the result of applying the given accumulating function to each pair of…
`forItem()` | A function that returns the result of applying the given function to the item of a given…
`forKey()` | A function that returns the result of applying the given function to the key of a given [[…
`formal()` | Annotation to mark a member whose implementation must be provided by subtypes.
`formatFloat()` | The string decimal representation of the given floating point number.
`formatInteger()` | The string representation of the given `integer` in the base given by `radix`.
`identical()` | Determine if the arguments are `identical()`.
`identity()` | The identity function that always returns its argument.
`identityHash()` | Return the system-defined identity hash value of the given value.
`increasing()` | A comparator function which orders elements in increasing natural order.
`increasingItem()` | A comparator function which orders entries by increasing natural order of their [[items|…
`increasingKey()` | A comparator function which orders entries by increasing natural order of their [[keys|…
`infinity` | An instance of `Float` representing positive infinity, ∞, the result of dividing a positive number by zero.
`interleave()` | Given one or more argument streams, return a stream containing elements of the given streams.
`invariant` | Invariant means that neither subtype nor supertype can be accepted, the type has to be exactly that which is declared.
`language` | Contains information about the Ceylon language version.
`larger` | The value is larger than the given value.
`largest()` | Given two `Comparable` values, return largest of the two.
`late()` | Annotation to disable definite initialization analysis for a reference.
`license()` | Annotation to specify the URL of the license of a module or package.
`loop()` | Produces the stream that results from repeated application of the given function to the given [[…
`map()` | Create a new immutable `Map` containing every `Entry` produced by the given `stream`, resolving items with…
`mapPairs()` | Given two streams, form a new stream by applying a binary mapping function to pairs of elements in the…
`max()` | Given a stream of `Comparable` values, return the largest value in the stream, or `null` if the stream is empty.
`measure()` | Produces a `Range` of adjacent `Enumerable` values generated by a `first` element, and a strictly positive [[…
`min()` | Given a stream of `Comparable` values, return the smallest value in the stream, or `null` if the stream is empty.
`modules` | Represents the list of Ceylon modules currently loaded at runtime.
`native()` | Annotation to mark a member whose implementation is defined in platform-native code.
`noop()` | A `void` function that does nothing.
`not()` | Returns a function which is the logical negation of the given predicate function.
`nothing` | A value getter of type `Nothing`.
`nothingType` | The singleton open type for Nothing.
`nothingType` | The singleton closed type for Nothing.
`null` | The null value.
`operatingSystem` | Represents the operating system on which the current process is running.
`optional()` | Annotation to specify that a module can be executed even if the annotated dependency is not available.
`optionalAnnotation()` | The value of given optional annotation type on the given program element, or null if the program element was not…
`or()` | Returns a function which is the logical disjunction of the given predicate functions.
`parseBoolean()` | The `Boolean` value of the given string representation of a boolean value, or `null` if the string does not represent…
`parseFloat()` | The `Float` value of the given string representation of a decimal floating point number, or `null` if…
`parseInteger()` | The `Integer` value of the given string representation of an integer value in the base given by [[radix]…
`plus()` | Add the given `Summable` values
`print()` | Print a line to the standard output of the virtual machine process, printing the given value's `string`, or `<null>`…
`printAll()` | Print multiple values to the standard output of the virtual machine process as a single line of text, separated by a…
`printStackTrace()` | Print the stack trace of the given `Exception` using the given function, or to [[standard error|…
`process` | Represents the current process (instance of the virtual machine).
`product()` | Given a nonempty stream of `Numeric` values, return the product of the values.
`runtime` | Represents the machine and virtual machine on which the current process is executing.
`sealed()` | Annotation to mark an interface, class, or constructor as sealed.
`see()` | Annotation to specify references to other program elements related to the annotated API.
`sequence()` | A nonempty sequence of the given `elements`, or `null` if the given stream is empty.
`sequencedAnnotations()` | The values of given sequenced annotation type on the given program element, or empty if the program element was not…
`serializable()` | Annotation to specify that a class is serializable.
`serialization()` | A new `SerializationContext`.
`set()` | Create a new immutable `Set` containing every element produced by the given `stream`, resolving items with…
`shared()` | Annotation to mark a declaration as shared.
`shuffle()` | Given a function with two parameter lists, return a function with the order of the argument lists reversed.
`smaller` | The value is smaller than the given value.
`smallest()` | Given two `Comparable` values, return smallest of the two.
`sort()` | Sort the given elements according to their natural order, returning a new sequence.
`span()` | Produces a `Range` of adjacent `Enumerable` values generated by two endpoints: `first` and `last`.
`sum()` | Given a nonempty stream of `Summable` values, return the sum of the values.
`suppressWarnings()` | Annotation to suppress compilation warnings of the specified types when typechecking the annotated…
`system` | Represents the system on which the current process is executing.
`tagged()` | Annotation to categorize an API by tag.
`throws()` | Annotation to document the exception types thrown by a function, value, class, or constructor.
`times()` | Multiply the given `Numeric` values
`true` | A value representing truth in Boolean logic.
`type()` | Returns the closed type and model of a given instance.
`typeLiteral()` | Functional equivalent to type literals.
`uncurry()` | Uncurries a function, returning a function with one parameter list, given a function with two parameter lists, where…
`unflatten()` | Given a function with parameter types `P1`, `P2`, …, `Pn`, return a function with a single parameter of tuple type…
`uninitializedLateValue` | A singleton used to indicate that a `late` `Member` of a particular instance has not been initialized.
`unzip()` | Given a stream of tuples, return two streams.
`unzipEntries()` | Given a stream of entries, return two streams.
`unzipPairs()` | Given a stream of pairs, return two streams.
`variable()` | Annotation to mark a value as variable.
`zip()` | Given a stream of values, and a stream of tuples, produce a new stream of tuples formed by prepending the…
`zipEntries()` | Given two streams, form a new stream consisting of all entries where, for any given index in the resulting…
`zipPairs()` | Given two streams, form a new stream consisting of all pairs where, for any given index in the resulting stream, the…