sdthompson1
commented
2 days ago At the same time I'm going to change the syntax for "external" types (corresponding to void* in C) from type Foo; to extern type Foo;. This will avoid confusion between two different uses of type Foo;.
So to summarise, the type keyword will now be usable as follows:
extern type Foo;-- this defines a new type Foo, corresponding to void* in Ctype Foo = something;-- this defines Foo to be a synonym forsomething.type Foo;-- this can only appear in interfaces; it declares a new type Foo, whose definition (eitherextern type Foo;,type Foo = something;, ordatatype Foo = something;) is to be given in the module's implementation. Within module Foo, the definition will be available, but from the point of view of other modules (i.e. importers of this module), Foo will just be an abstract type.
It should be possible to write
type Foo;in the interface, but havetype Foo = somethingordatatype Foo = somethingin the implementation.For now the codegen for this will work by "looking inside" the imported module to see what the implementation of the type is, and then just using that as normal. This means we won't be able to do separate compilation, unfortunately, but compilation times are fairly fast, so this is not a big issue (and we can always add separate compilation back in later).
The renamer might have to be modified to ensure that e.g. constructor names are hidden outside of the module. The typechecker will have to hide the actual implementation of the type from other modules (merely exporting it as an "abstract type" as if
type Foo;had been used all along). The verifier is similar - we just have to make sure that in external modules, the type is considered to betype Foo;rather than its real definition.This shouldn't therefore be all that hard to do.
If the type contains allocated-predicates (#3) then the allocated-predicate given in the interface must be implied by the one given in the implementation. I.e. the interface might lie and say the type is allocated, when it isn't really; but it can't lie the other way around and say that the type isn't allocated when it is.