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:

Annotation

The supertype of all annotation classes.

AnnotationAnnotation

The annotation class for the annotation() meta-annotation.

Anything

The abstract supertype of all types. A

Applicable

Represents classes or functions that you can apply in a type-unsafe way.

Array

A fixed-sized array of mutable elements. A

ArraySequence

A Sequence backed by an Array.

AssertionError

An error that occurs due to an incorrectly written program. A

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

Binary

Abstraction of types that are conceptually a sequence of bits, and may be the subject of bitwise operations. A

Boolean

A type capable of representing the values true and false of Boolean logic.

Byte

An 8-bit byte. A

Callable

A reference to a function. T

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

Category

Abstract supertype of objects that contain other values, called elements, where it is possible to efficiently determine i…

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.

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

CorrespondenceMutator

A Correspondence that supports mutation of its constituent key/item associations.

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 statement c…

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

Entry

A pair containing a key and an associated value called the item. U

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

Exponentiable

Abstraction of numeric types that may be raised to a power using the exponentiation operator x ^ n which accepts an i…

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

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

Identifiable

The abstract supertype of all types with a well-defined notion of identity. V

Import

Model of an import declaration within a module declaration.

IncompatibleTypeException

Thrown when you invoke metamodel methods with invalid or incompatible type arguments.

IndexedCorrespondenceMutator

A CorrespondenceMutator which allows mutation of the item associated with a given integer index from a range of…

InitializationError

Assertion failure that occurs when a value reference could not be initialized, including when:

Integer

An exact representation of a positive whole number, negative whole number, or zero.

Integral

Abstraction of integral numeric types. T

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 of x. E

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

Iterator

Produces the elements of a stream. F

KeyedCorrespondenceMutator

A CorrespondenceMutator which allows mutation of the item associated with an existing key, and creation of a new key/i…

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

Map

A collection which maps keys to items, where a key can map to at most one item. E

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

Number

Abstraction of numeric types with a natural total order, including the built-in numeric types Integer and Float.

Numeric

Abstraction of numeric types with the usual binary operations:

Object

The abstract supertype of all types representing definite values. A

Obtainable

Abstract supertype of resources which may be obtained at the beginning of a try statement and then released when the s…

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,…

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

Ranged

Abstract supertype of ranged streams mapping a range of discrete indices to elements of the stream, and supporting o…

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

Scalable

Abstract supertype of types that support scaling by a numeric factor. E

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 of…

SeeAnnotation

The annotation class for the see() annotation.

Sequence

A nonempty, immutable sequence of values. T

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

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

ServiceAnnotation

The annotation class for the service() annotation.

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.

SinceAnnotation

The annotation class for the since() annotation.

Singleton

A Sequence with exactly one Singleton.element, which may be null.

SmallAnnotation

The annotation class for the small() annotation.

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

StringBuilder

Builder utility for constructing strings by incrementally appending strings or characters.

Summable

Abstraction of types which support a binary addition operator x + y. F

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

ThrownExceptionAnnotation

The annotation class for the throws() annotation.

Tuple

A tuple is a typed linked list. E

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

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

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)

arrayOfSize()

Create an array of the specified size, populating every index with the given element. T

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 returned by t…

byIncreasing()

Produces a comparator function which orders elements in increasing order according to the Comparable value returned by t…

byItem()

A comparator for Entrys which compares their items according to the given comparing() function.

byKey()

A comparator for Entrys which compares their keys according to the given comparing() function.

classDeclaration()

Returns the class declaration for a given instance. S

className()

Return the name of the concrete class of the given object, in a format native to the virtual machine. F

compareCorresponding()

Compares corresponding elements of the given streams using the given comparison function. T

comparing()

A single comparator function which delegates to each of the given comparator functions in turn, returning the first r…

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

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 []. T

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 otherwise. T

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

false

A value representing falsity in Boolean logic.

final()

Annotation to mark a class as final. A

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 parameters of t…

foldPairs()

Given two streams, return the result of applying the given accumulating function to each pair of elements of the given…

forItem()

A function that returns the result of applying the given function to the item of a given Entry, discarding its key.

forKey()

A function that returns the result of applying the given function to the key of a given Entry, discarding its item.

formal()

Annotation to mark a member whose implementation must be provided by subtypes.

formatFloat()

The string decimal representation of the given floating point number. I

formatInteger()

The string representation of the given integer in the base given by radix. I

identical()

Determine if the arguments are identical(). E

identity()

The identity function that always returns its argument.

identityHash()

Return the system-defined identity hash value of the given value. T

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

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 first element of the s…

map()

Create a new immutable Map containing every Entry produced by the given stream, resolving items with duplicate keys a…

mapPairs()

Given two streams, form a new stream by applying a binary mapping function to pairs of elements in the given streams.

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 size, or returns t…

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

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 a…

parseFloat()

The Float value of the given string representation of a decimal floating point number, or null if the string does not…

parseInteger()

The Integer value of the given string representation of an integer value in the base given by radix, or null if the s…

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> if the v…

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 if no function is specified.

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

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

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.

service()

Annotation marking a class as implementing a service.

set()

Create a new immutable Set containing every element produced by the given stream, resolving items with duplicate keys a…

shared()

Annotation to mark a declaration as shared. A

shuffle()

Given a function with two parameter lists, return a function with the order of the argument lists reversed.

since()

Annotation to indicate at which moment the annotated declaration was added to the module.

small()

Annotation to hint to the compiler that an Integer or Float typed value or function should be represented using a 32-b…

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

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 program element.

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

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 [P1, P2, ..…

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

zip()

Given a stream of values, and a stream of tuples, produce a new stream of tuples formed by prepending the values in the

zipEntries()

Given two streams, form a new stream consisting of all entries where, for any given index in the resulting stream, the

zipPairs()

Given two streams, form a new stream consisting of all pairs where, for any given index in the resulting stream, the f…