The Ceylon metamodel closed type and model package.

As described in the ceylon.language.meta documentation, this package contains all the types that represent Ceylon closed types and models.

Usage example

The following code will list all the value declarations in the ceylon.language package and print their current value:

Package languagePackage = `package ceylon.language`;
ValueDeclaration[] valueDeclarations = languagePackage.members<ValueDeclaration>();
Value<Anything>[] valueModels = valueDeclarations*.apply<Anything>();
for(val in valueModels){
    // skip the nothing value which cannot be read
    if(val.type != `Nothing`){
        print(val.get());
    }
}

The following code will iterate all the class declarations in the ceylon.language package that are not abstract, anonymous or annotations, and that have no type parameters nor initialiser parameters. For each matching class, we will apply it to get a class model which we can then use to instantiate the class and display its instance:

for(decl in `package ceylon.language`.members<ClassDeclaration>()){
    if(!decl.abstract 
            && !decl.anonymous 
            && !decl.annotation
            && decl.parameterDeclarations.empty
            && decl.typeParameterDeclarations.empty){
        Class<Object,[]> classModel = decl.classApply<Object,[]>();
        Object instance = classModel();
        print("Instance of ``decl.name`` is: ``instance``");
    }
}
By: Gavin King, Stephane Epardaud
Values
nothingTypeSource Codeshared nothingType nothingType

The singleton closed type for Nothing.

Interfaces
ApplicableSource Codeshared Applicable<out Type = Anything>

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

AttributeSource Codeshared Attribute<in Container,out Get = Anything,in Set = Nothing>

An attribute model represents the model of a Ceylon attribute that you can read and inspect.

An attribute is a member value: it is declared on classes or interfaces.

This is both a ValueModel and a Member: you can invoke it with an instance value to bind it to that instance and obtain a Value:

class Outer(){
    shared String foo = "Hello";
}

void test(){
    Attribute<Outer,String> attribute = `Outer.foo`;
    Value<String> boundAttribute = attribute(Outer());
    // This will print: Hello
    print(boundAttribute.get());
}
ClassSource Codeshared Class<out Type = Anything,in Arguments = Nothing>

A class model represents the model of a Ceylon class that you can instantiate and inspect.

A class is a toplevel type, declared on a package.

This is a ClassModel that you can also invoke to instantiate new instances of the class:

shared class Foo(String name){
    shared String hello => "Hello "+name;
}

void test(){
    Class<Foo,[String]> c = `Foo`;
    // This will print: Hello Stef
    print(c("Stef").hello);
}
ClassModelSource Codeshared ClassModel<out Type = Anything,in Arguments = Nothing>

A class model represents the model of a Ceylon class that you can inspect.

A class model can be either a toplevel Class or a member MemberClass.

ClassOrInterfaceSource Codeshared ClassOrInterface<out Type = Anything>

Model of a class or interface that you can inspect.

The models of classes and interfaces are also closed types.

FunctionSource Codeshared Function<out Type = Anything,in Arguments = Nothing>

A function model represents the model of a Ceylon function that you can invoke and inspect.

A function is a toplevel binding, declared on a package.

This is a FunctionModel that you can also invoke:

shared String foo(String name) => "Hello "+name;

void test(){
    Function<String,[String]> f = `foo`;
    // This will print: Hello Stef
    print(f("Stef"));
}
FunctionModelSource Codeshared FunctionModel<out Type = Anything,in Arguments = Nothing>

A function model represents the model of a Ceylon function that you can inspect.

A function model can be either a toplevel Function or a member Method.

GenericSource Codeshared Generic

A generic model which has closed type arguments.

InterfaceSource Codeshared Interface<out Type = Anything>

An interface model that you can inspect.

InterfaceModelSource Codeshared InterfaceModel<out Type = Anything>

An interface model represents the model of a Ceylon interface that you can inspect.

An interface model can be either a toplevel Interface or a member MemberInterface.

IntersectionTypeSource Codeshared IntersectionType<out Intersection = Anything>

A closed intersection type.

MemberSource Codeshared Member<in Container,out Kind>
given Kind satisfies Model

Model for members that can be bound to a containing instance to turn them into toplevel models.

You can bind a member to an instance by invoking that member with the instance as parameter:

shared class Outer(String name){
    shared class Inner(){
        shared String hello => "Hello "+name;
    }
}

void test(){
    Member<Outer,Class<Outer.Inner,[]>> memberClass = `Outer.Inner`;
    Class<Outer.Inner,[]> c = memberClass(Outer("Stef"));
    // This will print: Hello Stef
    print(c().hello);
}
MemberClassSource Codeshared MemberClass<in Container,out Type = Anything,in Arguments = Nothing>

A class model represents the model of a Ceylon class that you can instantiate and inspect.

A member class is is declared on classes or interfaces.

This is both a ClassModel and a Member: you can invoke it with an instance value to bind it to that instance and obtain a Class:

shared class Outer(String name){
    shared class Inner(){
        shared String hello => "Hello "+name;
    }
}

void test(){
    MemberClass<Outer,Outer.Inner,[]> memberClass = `Outer.Inner`;
    Class<Outer.Inner,[]> c = memberClass(Outer("Stef"));
    // This will print: Hello Stef
    print(c().hello);
}
MemberInterfaceSource Codeshared MemberInterface<in Container,out Type = Anything>

A member interface model that you can inspect.

MethodSource Codeshared Method<in Container,out Type = Anything,in Arguments = Nothing>

A function model represents the model of a Ceylon function that you can invoke and inspect.

A method is a member function: it is declared on classes or interfaces.

This is both a FunctionModel and a Member: you can invoke it with an instance value to bind it to that instance and obtain a Function:

class Outer(){
    shared String foo(String name) => "Hello "+name;
}

void test(){
    Method<Outer,String,[String]> method = `Outer.foo`;
    // Bind it to an instance value
    Function<String,[String]> f = method(Outer());
    // This will print: Hello Stef
    print(f("Stef"));
}
ModelSource Codeshared Model

The root of all models. There are several types of models:

TypeSource Codeshared Type<out Type = Anything>

A closed type.

A closed type is a type which is fully resolved and bound and contains no open type variables. All instance types are closed at runtime.

You have only four sorts of types:

UnionTypeSource Codeshared UnionType<out Union = Anything>

A closed union type.

ValueSource Codeshared Value<out Get = Anything,in Set = Nothing>

A value model represents the model of a Ceylon value that you can read and inspect.

A value is a toplevel binding, declared on a package.

This is a ValueModel that you can query for a value declaration's current value:

shared String foo = "Hello";

void test(){
    Value<String> val = `foo`;
    // This will print: Hello
    print(val.get());
}
ValueModelSource Codeshared ValueModel<out Get = Anything,in Set = Nothing>

A value model represents the model of a Ceylon value that you can inspect.

A value model can be either a toplevel Value or a member Attribute.

Classes
nothingTypeSource Codeshared nothingType

The singleton closed type for Nothing.

Exceptions
IncompatibleTypeExceptionSource Codeshared IncompatibleTypeException

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

For example if you try to get an attribute from a class and expect an attribute of String type but it is an attribute of Integer type.

InvocationExceptionSource Codeshared InvocationException

Thrown when attempting to invoke something which can't be invoked, like abstract class initialisers.

MutationExceptionSource Codeshared MutationException

Thrown when you try to change the value of a non-variable value

TypeApplicationExceptionSource Codeshared TypeApplicationException

Thrown when declarations are applied with invalid or incompatible type arguments. Also throw when trying to apply member declarations with no containers, or toplevel declarations with a container.

For example if you try to apply Foo with String, hoping to get a Foo<String> but the type parameter for Foo only accepts types that satisfy Numeric.