SCL Registry

This pages documents a mechanism for finding and contributing SCL types and values in Simantics platform. All interfaces and classes mentioned are defined in the plugins org.simantics.scl.types, org.simantics.scl.reflection or org.simantics.scl.runtime.

Both types and values are identified by URIs. The last part of the URI is the name of the type or value and the prefix before the name is the namespace.

Types

Grammar and representation

SCL types are written according to the following grammar:

t ::= C                // Type constructor
    | a                // Type variable
    | t1 t2            // Type application
    | forall a. t      // Universal quantification
    | P t1 ... tn => t // Qualified type

Type constructor is either one capitalized identifier or concatenation of multiple identifiers with period (.). In the former case, the last identifier does not have to be capitalized. Type variable is always a one identifier that is not capitalized.

Types are represented in Java using the following subtypes of Type (org.simantics.scl.types)

TCon(String module, String name)
TVar()
TApply(Type function, Type parameter)
TForAll(TVar var, Type type)
TPred(TFuncApply predicate, Type type)

Some type constructors have special syntax:

a -> b   =   TApply(TApply(TCon(Types.BUILTIN, "->"), a), b)   
[a]      =   TApply(TCon(Types.BUILTIN, "[]"), a)
()       =   TCon(Types.BUILTIN, "()")
(a,b)    =   TApply(TApply(TCon(Types.BUILTIN, "(,)"), a), b)
(a,b,c)  =   TApply(TApply(TApply(TCon(Types.BUILTIN, "(,,)"), a), b), c)
...

A type is converted from a String to Type using Types.parseType.

Converting types to classes

In order to get a Java class from a type, TypeBindingScheme (org.simantics.scl.reflection) is needed. It describes which Java class each type constructor corresponds to. With a scheme s types are converted to classes with the following rules implemented in ReflectionUtils.getClass

c(C)                -->  s(C)
c(a)                --> Object
c(t1 t2)            --> c(t1)
c(forall a.t)       --> c(t)
c(P t1 ... tn => t) --> Function

A singleton MinimalTypeBindingScheme implements TypeBindingScheme that uses extensions to find bindings from type constructors to classes. It must be extended elsewhere in order to get for example the types defined in the database.

The following bindings are defined even when no extensions are defined:

(->)    -->  Function
[]      -->  List
()      -->  Tuple0
(,)     -->  Tuple2
(,,)    -->  Tuple3
...
Boolean --> Boolean
Byte    --> Byte   
...
Long    --> Long
String  --> String

Values

The type conversion rules in the previous section already dictate the Java class of the values of a certain SCL type. Depending on the type constructor, there are additional constraints. For example, values of type [a] must implement interface java.util.List and additionally elements of the list must be compatible with a. Values of type a -> b must implement the interface Function and additionally when method apply is called with a parameter compatible with type a the method must return a value compatible with type b.

Finding values

Values are found using ReflectionUtils.getValue. The method requires the URI of the value. This method does not cache the values.

Contributing types and values

Type are contributed putting SCLType-annotations to classes and values with SCLValue-annotations on fields, constructors and methods. Both annotations have an optioinal name-attribute, which can be used to override the default name that is the name of the class or method annotated. SCLValue -annotation has also a required type-annotation where the SCL type of the value must be declared.

In addition, classes containing these annotations must be declared using the extension point org.simantics.scl.reflection.binding. It has the following elements

namespace

attributes: path
possible children: class, namespace, externalClass, externalMethod, import
Represents a library or type in semantic graph. If the element is the root of the extension, path is an absolute uri of the resource. Otherwise it is relative path from its parent element.

class

attributes: className
Declares a Java class to be searched for annotations.

import

attributes: path, localName
Gives a path a localName that can be used to refer it in type declarations.

externalClass

Contributes a class without annotations.

externalMethod

Contributes a method without annotations.