On this page:
class/  c
absent
->m
->*m
case->m
->dm
object/  c
instanceof/  c
dynamic-object/  c
object-contract
mixin-contract
make-mixin-contract
is-a?/  c
implementation?/  c
subclass?/  c

6.7 Object and Class Contracts🔗ℹ

syntax

(class/c maybe-opaque member-spec ...)

 
maybe-opaque = 
  | #:opaque
  | #:opaque #:ignore-local-member-names
     
member-spec = method-spec
  | (field field-spec ...)
  | (init field-spec ...)
  | (init-field field-spec ...)
  | (inherit method-spec ...)
  | (inherit-field field-spec ...)
  | (super method-spec ...)
  | (inner method-spec ...)
  | (override method-spec ...)
  | (augment method-spec ...)
  | (augride method-spec ...)
  | (absent absent-spec ...)
     
method-spec = method-id
  | (method-id method-contract-expr)
     
field-spec = field-id
  | (field-id contract-expr)
     
absent-spec = method-id
  | (field field-id ...)
Produces a contract for a class.

There are two major categories of contracts listed in a class/c form: external and internal contracts. External contracts govern behavior when an object is instantiated from a class or when methods or fields are accessed via an object of that class. Internal contracts govern behavior when method or fields are accessed within the class hierarchy. This separation allows for stronger contracts for class clients and weaker contracts for subclasses.

Method contracts must contain an additional initial argument which corresponds to the implicit this parameter of the method. This allows for contracts which discuss the state of the object when the method is called (or, for dependent contracts, in other parts of the contract). Alternative contract forms, such as ->m, are provided as a shorthand for writing method contracts.

Methods and fields listed in an absent clause must not be present in the class.

A class contract can be specified to be opaque with the #:opaque keyword. An opaque class contract will only accept a class that defines exactly the external methods and fields specified by the contract. A contract error is raised if the contracted class contains any methods or fields that are not specified. Methods or fields with local member names (i.e., defined with define-local-member-name) are ignored for this check if #:ignore-local-member-names is provided.

The external contracts are as follows:

The internal contracts restrict the behavior of method calls made between classes and their subclasses; such calls are not controlled by the class contracts described above.

As with the external contracts, when a method or field name is specified but no contract appears, the contract is satisfied merely with the presence of the corresponding field or method.

syntax

(absent absent-spec ...)

See class/c; use outside of a class/c form is a syntax error.

syntax

(->m dom ... range)

Similar to ->, except that the domain of the resulting contract contains one more element than the stated domain, where the first (implicit) argument is contracted with any/c. This contract is useful for writing simpler method contracts when no properties of this need to be checked.

syntax

(->*m (mandatory-dom ...) (optional-dom ...) rest range)

Similar to ->*, except that the mandatory domain of the resulting contract contains one more element than the stated domain, where the first (implicit) argument is contracted with any/c. This contract is useful for writing simpler method contracts when no properties of this need to be checked.

syntax

(case->m (-> dom ... rest range) ...)

Similar to case->, except that the mandatory domain of each case of the resulting contract contains one more element than the stated domain, where the first (implicit) argument is contracted with any/c. This contract is useful for writing simpler method contracts when no properties of this need to be checked.

syntax

(->dm (mandatory-dependent-dom ...)
      (optional-dependent-dom ...)
      dependent-rest
      pre-cond
      dep-range)
Similar to ->d, except that the mandatory domain of the resulting contract contains one more element than the stated domain, where the first (implicit) argument is contracted with any/c. In addition, this is appropriately bound in the body of the contract. This contract is useful for writing simpler method contracts when no properties of this need to be checked.

syntax

(object/c member-spec ...)

 
member-spec = method-spec
  | (field field-spec ...)
     
method-spec = method-id
  | (method-id method-contract)
     
field-spec = field-id
  | (field-id contract-expr)
Produces a contract for an object.

Unlike the older form object-contract, but like class/c, arbitrary contract expressions are allowed. Also, method contracts for object/c follow those for class/c. An object wrapped with object/c behaves as if its class had been wrapped with the equivalent class/c contract.

procedure

(instanceof/c class-contract)  contract?

  class-contract : contract?
Produces a contract for an object, where the object is an instance of a class that conforms to class-contract.

procedure

(dynamic-object/c method-names    
  method-contracts    
  field-names    
  field-contracts)  contract?
  method-names : (listof symbol?)
  method-contracts : (listof contract?)
  field-names : (listof symbol?)
  field-contracts : (listof contract?)
Produces a contract for an object, similar to object/c but where the names and contracts for both methods and fields can be computed dynamically. The list of names and contracts for both methods and field respectively must have the same lengths.

syntax

(object-contract member-spec ...)

 
member-spec = (method-id method-contract)
  | (field field-id contract-expr)
     
method-contract = (-> dom ... range)
  | 
(->* (mandatory-dom ...)
     (optional-dom ...)
     rest
     range)
  | 
(->d (mandatory-dependent-dom ...)
     (optional-dependent-dom ...)
     dependent-rest
     pre-cond
     dep-range)
     
dom = dom-expr
  | keyword dom-expr
     
range = range-expr
  | (values range-expr ...)
  | any
     
mandatory-dom = dom-expr
  | keyword dom-expr
     
optional-dom = dom-expr
  | keyword dom-expr
     
rest = 
  | #:rest rest-expr
     
mandatory-dependent-dom = [id dom-expr]
  | keyword [id dom-expr]
     
optional-dependent-dom = [id dom-expr]
  | keyword [id dom-expr]
     
dependent-rest = 
  | #:rest id rest-expr
     
pre-cond = 
  | #:pre-cond boolean-expr
     
dep-range = any
  | [id range-expr] post-cond
  | (values [id range-expr] ...) post-cond
     
post-cond = 
  | #:post-cond boolean-expr
Produces a contract for an object.

Each of the contracts for a method has the same semantics as the corresponding function contract, but the syntax of the method contract must be written directly in the body of the object-contract—much like the way that methods in class definitions use the same syntax as regular function definitions, but cannot be arbitrary procedures. Unlike the method contracts for class/c, the implicit this argument is not part of the contract. To allow for the use of this in dependent contracts, ->d contracts implicitly bind this to the object itself.

A function contract that recognizes mixins. It guarantees that the input to the function is a class and the result of the function is a subclass of the input.

procedure

(make-mixin-contract type ...)  contract?

  type : (or/c class? interface?)
Produces a function contract that guarantees the input to the function is a class that implements/subclasses each type, and that the result of the function is a subclass of the input.

procedure

(is-a?/c type)  flat-contract?

  type : (or/c class? interface?)
Accepts a class or interface and returns a flat contract that recognizes objects that instantiate the class/interface.

See is-a?.

procedure

(implementation?/c interface)  flat-contract?

  interface : interface?
Returns a flat contract that recognizes classes that implement interface.

See implementation?.

procedure

(subclass?/c class)  flat-contract?

  class : class?
Returns a flat contract that recognizes classes that are subclasses of class.

See subclass?.