A tuple representing a type argument and its use-site variance.

The singleton closed type for Nothing.

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

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());
}

A callable constructor model represents the model of a Ceylon class constructor that you can invoke and inspect

Callablity

As with Function you can also invoke a CallableConstructor, doing so instantiates an instance:

 shared class Foo {
     shared String name;
     shared new foo(String name) {
         this.name = name;
     }
 }

 void test() {
 Constructor<Foo,[String]> ctor = `Foo.foo`;
 // This will print: Stef
 print(ctor("Stef").name);

Genericity

This class inherits Generic but a constructor in Ceylon cannot have a type parameters. For symmetry with CallableConstructorDeclaration.apply() the Generic.typeArguments and Generic.typeArgumentList refer to the type arguments of the constructor's class.

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);
}

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.

Model of a class or interface that you can inspect.

The models of classes and interfaces are also closed types.

A model element that has a declaration.

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"));
}

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

A function model can be either a toplevel Function, a CallableConstructor (callable constructor) of a toplevel Class, a member Method or CallableMemberConstructor (callable constructor) of a member class.

Abstraction for models which have a parameter list.

A generic model which has closed type arguments.

An abstraction of things that have a value which be got, and possibley set.

An interface model that you can inspect.

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.

A closed intersection type.

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);
}

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);
}

A model for a callable constructor of a member class.

A model for a value constructor of a member class.

A member interface model that you can inspect.

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"));
}

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

• ClassOrInterface
• FunctionModel
• ValueModel

Abstraction for models of elements which must be qualified by an instance to order to be evaluated, including:

• Attributes (a Qualified Value),
• Methods (a Qualified Function),
• MemberClass (member classes) (a Qualified Class) and,
• MemberClassConstructor (member constructors) (a constructor of a Qualified Class).

To qualify a Qualified metamodel instance in a type-safe way you simply invoke it. Alternatively use Qualified.bind() if the qualifying instance's type is unknown until runtime.

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:

• ClassOrInterface
• UnionType
• IntersectionType
• nothingType

A closed union type.

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());
}

A callable constructor model represents the model of a Ceylon class value constructor that you can get and inspect

Gettablity

As with Value you can also get the value of a ValueConstructor, doing so obtains instance:

 shared class Color {
     shared String hex;
     shared new black {
         this.hex="#000000";
     }
     shared new white {
         this.hex="#ffffff";
     }
 }

 void test() {
 ValueConstructor<Color> ctor = `Color.black`;
 // This will print: #000000
 print(ctor.get());

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.

The singleton closed type for Nothing.

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.

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

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

Thrown when you try to read attributes that were not shared nor captured and had no physical storage allocated, so do not exist at runtime.

For example if you try to read the attribute from this class:

shared class Foo(){
    Integer x = 2;
}

This will not work because x is neither shared nor captured and so it is just not retained in the runtime instances of Foo.

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.