Warning: the features described in this section are experimental and may not work correctly. Some of the features will change by the next release. In particular, typed-untyped interaction for classes will not be backwards compatible so do not rely on the current semantics.
Typed Racket provides support for object-oriented programming with the classes and objects provided by the racket/class library.
|(require typed/racket/class)||package: typed-racket-lib|
The special forms below are provided by the typed/racket/class and typed/racket modules but not by typed/racket/base. The typed/racket/class module additional provides all other bindings from racket/class.
(class superclass-expr maybe-type-parameters class-clause ...)
class-clause = (inspect inspector-expr) | (init init-decl ...) | (init-field init-decl ...) | (init-rest id/type) | (field field-decl ...) | (inherit-field field-decl ...) | (public maybe-renamed/type ...) | (pubment maybe-renamed/type ...) | (override maybe-renamed/type ...) | (augment maybe-renamed/type ...) | (private id/type ...) | (inherit id ...) | method-definition | definition | expr | (begin class-clause ...) maybe-type-parameters =
| #:forall (type-variable ...) | #:∀ (type-variable ...) init-decl = id/type | [renamed] | [renamed : type-expr] | [maybe-renamed default-value-expr] | [maybe-renamed : type-expr default-value-expr] field-decl = (maybe-renamed default-value-expr) | (maybe-renamed : type-expr default-value-expr) id/type = id | [id : type-expr] maybe-renamed/type = maybe-renamed | [maybe-renamed : type-expr] maybe-renamed = id | renamed renamed = (internal-id external-id)
The meaning of the class clauses are the same as in the class form from the racket/class library with the exception of the additional optional type annotations. Additional class clause forms from class that are not listed in the grammar above are not currently supported in Typed Racket.
Within a typed class form, one of the class clauses must be a call to super-new. Failure to call super-new will result in a type error. In addition, dynamic uses of super-new (e.g., calling it in a separate function within the dynamic extent of the class form’s clauses) are restricted.
When type-variable is provided, the class is parameterized over the given type variables. These type variables are in scope inside the body of the class. The resulting class can be instantiated at particular types using inst.
As in ordinary Racket classes, the order in which initialization arguments are declared determines the order of initialization types in the class type.
Furthermore, a class may also have a typed init-rest clause, in which case the class constructor takes an unbounded number of arguments by-position. The type of the init-rest clause must be either a List type, Listof type, or any other list type.
(Class class-type-clause ...)
class-type-clause = name+type | (init init-type ...) | (init-field init-type ...) | (init-rest name+type) | (field name+type ...) | (augment name+type ...) | #:implements type-alias-id | #:row-var row-var-id init-type = name+type | [id type #:optional] name+type = [id type]
The types of methods are provided either without a keyword, in which case they correspond to public methods, or with the augment keyword, in which case they correspond to a method that can be augmented.
An initialization argument type specifies a name and type and optionally a #:optional keyword. An initialization argument type with #:optional corresponds to an argument that does not need to be provided at object instantiation.
When type-alias-id is provided, the resulting class type includes all of the initialization argument, method, and field types from the specified type alias (which must be an alias for a class type). Multiple #:implements clauses may be provided for a single class type.
When row-var-id is provided, the class type is an abstract type that is row polymorphic. A row polymorphic class type can be instantiated at a specific row using inst. Only a single #:row-var clause may appear in a class type.
This is the same as an Object type that has all of the method and field types from class-type-expr. The types for the augment and init clauses in the class type are ignored.