import ceylon.language.meta.model { Interface, MemberInterface, AppliedType = Type, IncompatibleTypeException, TypeApplicationException } """An interface declaration. <a name="toplevel-sample"></a> ### Usage sample for toplevel interfaces Because some interfaces have type parameters, getting a model requires applying type arguments to the interface declaration with [[interfaceApply]] in order to be able to get a closed type. For example, here is how you would obtain an interface model from a toplevel interface declaration: interface Foo<T> satisfies List<T> { } void test(){ // We need to apply the Integer closed type to the Foo declaration in order to get the Foo<Integer> closed type Interface<Foo<Integer>> interfaceModel = `interface Foo`.interfaceApply<Foo<Integer>>(`Integer`); // This will print: ceylon.language::List<ceylon.language::Integer> for(satisfiedType in interfaceModel.satisfiedTypes){ print(satisfiedType); } } <a name="member-sample"></a> ### Usage sample for member interfaces For member interfaces it is a bit longer, because member interfaces need to be applied not only their type arguments but also the containing type, so you should use [[memberInterfaceApply]] and start by giving the containing closed type: class Outer(){ shared interface Inner<T> satisfies List<T> { } } void test(){ // apply the containing closed type `Outer` to the member class declaration `Outer.Inner` MemberInterface<Outer,Outer.Inner<Integer>> memberInterfaceModel = `interface Outer.Inner`.memberInterfaceApply<Outer,Outer.Inner<Integer>>(`Outer`, `Integer`); // This will print: ceylon.language::List<ceylon.language::Integer> for(satisfiedType in memberInterfaceModel.satisfiedTypes){ print(satisfiedType); } } """ shared sealed interface InterfaceDeclaration satisfies ClassOrInterfaceDeclaration { "Applies the given closed type arguments to this toplevel interface declaration in order to obtain an interface model. See [this code sample](#toplevel-sample) for an example on how to use this." throws(`class IncompatibleTypeException`, "If the specified `Type` type argument is not compatible with the actual result.") throws(`class TypeApplicationException`, "If the specified closed type argument values are not compatible with the actual result's type parameters.") shared formal Interface<Type> interfaceApply<Type=Anything>(AppliedType<>* typeArguments); "Applies the given closed container type and type arguments to this member interface declaration in order to obtain a member interface model. See [this code sample](#member-sample) for an example on how to use this." throws(`class IncompatibleTypeException`, "If the specified `Container` or `Type` type arguments are not compatible with the actual result.") throws(`class TypeApplicationException`, "If the specified closed container type or type argument values are not compatible with the actual result's container type or type parameters.") shared formal MemberInterface<Container, Type> memberInterfaceApply<Container=Nothing, Type=Anything>(AppliedType<Object> containerType, AppliedType<>* typeArguments); }