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:

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

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

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…