On this page:
object?
class?
interface?
generic?
object=?
object-or-false=?
object=-hash-code
object->vector
class->interface
object-interface
is-a?
subclass?
implementation?
interface-extension?
method-in-interface?
interface->method-names
object-method-arity-includes?
field-names
object-info
class-info
exn:  fail:  object
class-seal
class-unseal

6.11 Object, Class, and Interface Utilities🔗

procedure

(object? v)  boolean?

  v : any/c
Returns #t if v is an object, #f otherwise.

Examples:
> (object? (new object%))

#t

> (object? object%)

#f

> (object? "clam chowder")

#f

procedure

(class? v)  boolean?

  v : any/c
Returns #t if v is a class, #f otherwise.

Examples:
> (class? object%)

#t

> (class? (class object% (super-new)))

#t

> (class? (new object%))

#f

> (class? "corn chowder")

#f

procedure

(interface? v)  boolean?

  v : any/c
Returns #t if v is an interface, #f otherwise.

Examples:
> (interface? (interface () empty cons first rest))

#t

> (interface? object%)

#f

> (interface? "gazpacho")

#f

procedure

(generic? v)  boolean?

  v : any/c
Returns #t if v is a generic, #f otherwise.

Examples:
> (define c%
    (class object%
      (super-new)
      (define/public (m x)
        (+ 3.14 x))))
> (generic? (generic c% m))

#t

> (generic? c%)

#f

> (generic? "borscht")

#f

procedure

(object=? a b)  boolean?

  a : object?
  b : object?
Determines whether a and b were returned from the same call to new or not. If the two objects have fields, this procedure determines whether mutating a field of one would change that field in the other.

This procedure is similar in spirit to eq? but also works properly with contracts (and has a stronger guarantee).

Examples:
> (define obj-1 (new object%))
> (define obj-2 (new object%))
> (define/contract obj-3 (object/c) obj-1)
> (object=? obj-1 obj-1)

#t

> (object=? obj-1 obj-2)

#f

> (object=? obj-1 obj-3)

#t

> (eq? obj-1 obj-1)

#t

> (eq? obj-1 obj-2)

#f

> (eq? obj-1 obj-3)

#f

procedure

(object-or-false=? a b)  boolean?

  a : (or/c object? #f)
  b : (or/c object? #f)
Like object=?, but accepts #f for either argument and returns #t if both arguments are #f.

Examples:

Added in version 6.1.1.8 of package base.

procedure

(object=-hash-code o)  fixnum?

  o : object?
Returns the hash code for o that corresponds to the equality relation object=?.

Added in version 7.1.0.6 of package base.

procedure

(object->vector object [opaque-v])  vector?

  object : object?
  opaque-v : any/c = #f
Returns a vector representing object that shows its inspectable fields, analogous to struct->vector.

Examples:
> (object->vector (new object%))

'#(object:object% ...)

> (object->vector (new (class object%
                         (super-new)
                         (field [x 5] [y 10]))))

'#(object:eval:113:0 ...)

procedure

(class->interface class)  interface?

  class : class?
Returns the interface implicitly defined by class.

Example:
> (class->interface object%)

#<interface:object%>

procedure

(object-interface object)  interface?

  object : object?
Returns the interface implicitly defined by the class of object.

Example:
> (object-interface (new object%))

#<interface:object%>

procedure

(is-a? v type)  boolean?

  v : any/c
  type : (or/c interface? class?)
Returns #t if v is an instance of a class type or a class that implements an interface type, #f otherwise.

Examples:
> (define point<%> (interface () get-x get-y))
> (define 2d-point%
    (class* object% (point<%>)
      (super-new)
      (field [x 0] [y 0])
      (define/public (get-x) x)
      (define/public (get-y) y)))
> (is-a? (new 2d-point%) 2d-point%)

#t

> (is-a? (new 2d-point%) point<%>)

#t

> (is-a? (new object%) 2d-point%)

#f

> (is-a? (new object%) point<%>)

#f

procedure

(subclass? v cls)  boolean?

  v : any/c
  cls : class?
Returns #t if v is a class derived from (or equal to) cls, #f otherwise.

Examples:

procedure

(implementation? v intf)  boolean?

  v : any/c
  intf : interface?
Returns #t if v is a class that implements intf, #f otherwise.

Examples:
> (define i<%> (interface () go))
> (define c%
    (class* object% (i<%>)
      (super-new)
      (define/public (go) 'go)))
> (implementation? c% i<%>)

#t

> (implementation? object% i<%>)

#f

procedure

(interface-extension? v intf)  boolean?

  v : any/c
  intf : interface?
Returns #t if v is an interface that extends intf, #f otherwise.

Examples:
> (define point<%> (interface () get-x get-y))
> (define colored-point<%> (interface (point<%>) color))
> (interface-extension? colored-point<%> point<%>)

#t

> (interface-extension? point<%> colored-point<%>)

#f

> (interface-extension? (interface () get-x get-y get-z) point<%>)

#f

procedure

(method-in-interface? sym intf)  boolean?

  sym : symbol?
  intf : interface?
Returns #t if intf (or any of its ancestor interfaces) includes a member with the name sym, #f otherwise.

Examples:
> (define i<%> (interface () get-x get-y))
> (method-in-interface? 'get-x i<%>)

#t

> (method-in-interface? 'get-z i<%>)

#f

procedure

(interface->method-names intf)  (listof symbol?)

  intf : interface?
Returns a list of symbols for the method names in intf, including methods inherited from superinterfaces, but not including methods whose names are local (i.e., declared with define-local-member-name).

Examples:
> (define i<%> (interface () get-x get-y))
> (interface->method-names i<%>)

'(get-x get-y)

procedure

(object-method-arity-includes? object    
  sym    
  cnt)  boolean?
  object : object?
  sym : symbol?
  cnt : exact-nonnegative-integer?
Returns #t if object has a method named sym that accepts cnt arguments, #f otherwise.

Examples:
> (define c%
    (class object%
      (super-new)
      (define/public (m x [y 0])
        (+ x y))))
> (object-method-arity-includes? (new c%) 'm 1)

#t

> (object-method-arity-includes? (new c%) 'm 2)

#t

> (object-method-arity-includes? (new c%) 'm 3)

#f

> (object-method-arity-includes? (new c%) 'n 1)

#f

procedure

(field-names object)  (listof symbol?)

  object : object?
Returns a list of all of the names of the fields bound in object, including fields inherited from superinterfaces, but not including fields whose names are local (i.e., declared with define-local-member-name).

Examples:
> (field-names (new object%))

'()

> (field-names (new (class object% (super-new) (field [x 0] [y 0]))))

'(x y)

procedure

(object-info object)  
(or/c class? #f) boolean?
  object : object?
Returns two values, analogous to the return values of struct-info:
  • class: a class or #f; the result is #f if the current inspector does not control any class for which the object is an instance.

  • skipped?: #f if the first result corresponds to the most specific class of object, #t otherwise.

Returns seven values, analogous to the return values of struct-type-info:

struct

(struct exn:fail:object exn:fail ()
    #:extra-constructor-name make-exn:fail:object)
Raised for class-related failures, such as attempting to call a method that is not supplied by an object.

procedure

(class-seal class    
  key    
  unsealed-inits    
  unsealed-fields    
  unsealed-methods    
  inst-proc    
  member-proc)  class?
  class : class?
  key : symbol?
  unsealed-inits : (listof symbol?)
  unsealed-fields : (listof symbol?)
  unsealed-methods : (listof symbol?)
  inst-proc : (-> class? any)
  member-proc : (-> class? (listof symbol?) any)
Adds a seal to a given class keyed with the symbol key. The given unsealed-inits, unsealed-fields, and unsealed-methods list corresponding class members that are unaffected by sealing.

When a class has any seals, the inst-proc procedure is called on instantiation (normally, this is used to raise an error on instantiation) and the member-proc function is called (again, this is normally used to raise an error) when a subclass attempts to add class members that are not listed in the unsealed lists.

The inst-proc is called with the class value on which an instantiation was attempted. The member-proc is called with the class value and the list of initialization argument, field, or method names.

procedure

(class-unseal class key wrong-key-proc)  class?

  class : class?
  key : symbol?
  wrong-key-proc : (-> class? any)
Removes a seal on a class that has been previously sealed with the class-seal function and the given key.

If the unseal removed all of the seals in the class, the class value can be instantiated or subclassed freely. If the given class value does not contain or any seals or does not contain any seals with the given key, the wrong-key-proc function is called with the class value.