The quid-pro-quo Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The quid-pro-quo Reference Manual

This is the quid-pro-quo Reference Manual, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:28:42 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Quid Pro Quo

A contract programming library for Common Lisp in the style of Eiffel’s Design by Contract ™.

What is it all about?

One main goals of every program is reliability, that is, correctness and robustness. A program is correct if it performs according to its specification, it is robust if it handles situations that were not covered in the specification in a graceful manner. One way to prove the correctness of a program with respect to a (formal) specification is the Hoare calculus. Based on this formal method Bertrand Meyer developed a method of software engineering called Design by Contract ™.

The principal idea of contract programming is that a class and its clients have a contract with each other: The client must guarantee certain conditions before calling a method specialized on the class (the preconditions), the class guarantees certain properties after the call (the postconditions). If the pre- and postconditions are included in a form that the compiler can check, then any violation of the contract between caller and class can be detected immediately.

Support for Contract Programming in Programming Languages

The language that offers the best support for contract programming is Eiffel, designed by Bertrand Meyer. It is rather difficult to add support for contract programming to most other languages, but not so for Common Lisp: I [Matthias Hölzl] have written a package for Common Lisp that provides support for contract programming. It is still very new and not too well tested so you should expect some rough edges and changes in its future design. There is no larger program depending on this package available, only some silly test cases. Since I intend to use the Quid Pro Quo package for my own programs this should change in the not so distant future.

Contract Programming in Common Lisp.

One of the outstanding features of the Eiffel language is that it supports a concept called contract programming. A comprehensive description is given in the following books

Object Oriented Software Construction, 2nd ed. Bertrand Meyer Prentice Hall PTR, 1997 ISBN 0-13-629155-4

Eiffel: The Language, 2nd ed. Bertrand Meyer Prentice Hall PTR, 1992 ISBN ???

but the key point of contract programming is that the relationship between a class and its clients is specified by a contract: There are certain conditions that the caller of a method specialized on a class has to fulfill so that the method can do its job (the preconditions) and the method guarantees certain things after its completion (the postconditions). Furthermore a class may have certain properties that are always true about that class; these properties are called invariants.

This file contains an implementation of contract programming for CLOS. Pre- and postconditions as well as invariants are specified by qualified methods of type contract; the usual before, after and around method combinations are available for these methods as well.

Implementation Support

Usage

Preconditions (defrequirement) and postconditions (defguarantee) are added to functions. This works for both generic and non-generic functions (but contracts on non-generic functions may do nothing on certain lisp implementations).

(defrequirement put (item (stack stack))
  "the stack is not full"
  (declare (ignore item))
  (not (full stack)))

(defguarantee put (item (stack stack))
  (and (not (empty stack))
       (eq (top-item stack) item)
       (= (count stack) (1+ (old (count stack))))))

(defguarantee pop-stack ((stack stack))
  (and (not (full stack))
       (eq (results) (old (top-item stack)))
       (= (count stack) (1- (old (count stack)))))

This simple example illustrates a few things:

These contracts can also be created similarly to :before and :after methods, primarily for defgeneric convenience. In this case, the optional description of what is being required or guaranteed can be included between the method qualifier and the lambda list (this is because the docstring is not necessarily accessible).

(defgeneric put (item stack)
  (:method :require "the stack is not full" (item (stack stack))
    (declare (ignore item))
    (not (full stack)))
  (:method :guarantee (item (stack stack))
    (and (not (empty stack))
         (eq (top-item stack) item)
         (= (count stack) (1+ (old (count stack))))))

(defmethod pop-stack :guarantee ((stack stack))
  (and (not (full stack))
       (eq (results) (old (top-item stack)))
       (= (count stack) (1- (old (count stack)))))

Invariants can be placed on classes.

(defclass stack ()
  ((capacity :initarg :capacity :reader capacity :type integer)
   (count :initform 0 :reader count :type integer)
   (top-item :reader top-item))
  (:metaclass contracted-class)
  (:invariants (lambda (instance)
                 "the count must be between 0 and the capacity"
                 (<= 0 (count instance) (capacity instance)))
               (lambda (instance)
                 "there is no top-item if the stack is empty"
                 (implies (empty instance)
                          (not (slot-boundp instance 'top-item))))))

In order to have invariants on a class, the metaclass must be specified as contracted-class.

Invariants are added to classes explicitly with the :invariants option, which allows you to specify any number of predicates that take the instance as their only argument. When available (depending on the Lisp implementation), the documentation string for the function is used. If no documentation is available, we fall back to the body (in the case of a lambda) or the function name and its documentation as the description.

This also illustrates another macro that is useful in contracts – implies. With implies, the second argument is only tested if the first argument is true.

Types are also checked as invariants. Most implementations check slot types little enough that it's possible for a bad value to end up there in some cases.

The description is included in the report if a contract-violation-error is raised. The description is also added to the documentation for the class, function, or primary method as appropriate. Slot type declarations are also


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 quid-pro-quo

Maintainer

Greg Pfeil <greg@technomadic.org>

Author

Matthias Hoelzl <tc@gauss.muc.de>

License

Public Domain

Description

A contract programming library for Common Lisp in the style of Eiffel’s Design by Contract.

Long Description

See README.md

Dependencies
Source

quid-pro-quo.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 quid-pro-quo.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/quid-pro-quo-20140713-git/quid-pro-quo.asd

Systems

quid-pro-quo (system)

Packages

quid-pro-quo.system


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 quid-pro-quo/package.lisp

Parent

quid-pro-quo (system)

Location

package.lisp

Packages

quid-pro-quo


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 quid-pro-quo/utilities.lisp

Dependency

package.lisp (file)

Parent

quid-pro-quo (system)

Location

utilities.lisp

Exported Definitions

implies (macro)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 quid-pro-quo/conditions.lisp

Dependency

package.lisp (file)

Parent

quid-pro-quo (system)

Location

conditions.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 quid-pro-quo/method-combination.lisp

Dependency

package.lisp (file)

Parent

quid-pro-quo (system)

Location

method-combination.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 quid-pro-quo/sbcl-encapsulate.lisp

Dependency

package.lisp (file)

Parent

quid-pro-quo (system)

Location

sbcl-encapsulate.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 quid-pro-quo/macros.lisp

Dependencies
Parent

quid-pro-quo (system)

Location

macros.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.8 quid-pro-quo/metaclass.lisp

Dependency

macros.lisp (file)

Parent

quid-pro-quo (system)

Location

metaclass.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.9 quid-pro-quo/system-connections.lisp

Description

Enumerates conditionally-loaded files. Look
here for the other files that may be loaded with this system.

Dependency

metaclass.lisp (file)

Parent

quid-pro-quo (system)

Location

system-connections.lisp


Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 quid-pro-quo.system

Source

/home/quickref/quicklisp/dists/quicklisp/software/quid-pro-quo-20140713-git/quid-pro-quo.asd

Use List

Previous: , Up: Packages   [Contents][Index]

4.2 quid-pro-quo

Source

package.lisp (file)

Nickname

qpq

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *invariant-initializers*

This is a list of functions that add invariants to some methods on a class. Each function must take the class as an argument. The return value is ignored.

Package

quid-pro-quo

Source

metaclass.lisp (file)

Special Variable: *verify-preconditions-p*

If NIL, we run only the most-specific precondition, otherwise we run all preconditions to make sure no less-specific preconditions are overly strict.

Package

quid-pro-quo

Source

method-combination.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: defguarantee NAME (&rest LAMBDA-LIST) &body BODY

Adds a postcondition to the NAMEd function. It can be either a generic or non-generic function. If it’s the former, then use a specialized lambda list, otherwise use an ordinary lambda list. The docstring, if any, will be used in failure reports.

Package

quid-pro-quo

Source

macros.lisp (file)

Macro: defrequirement NAME (&rest LAMBDA-LIST) &body BODY

Adds a precondition to the NAMEd function. It can be either a generic or non-generic function. If it’s the former, then use a specialized lambda list, otherwise use an ordinary lambda list. The docstring, if any, will be used in failure reports.

Package

quid-pro-quo

Source

macros.lisp (file)

Macro: implies CONDITION CONSEQUENT

A boolean operator that evaluates to the value of CONSEQUENT if CONDITION is true, and otherwise evaluates to T. This isn’t particularly specific to Quid Pro Quo, but it is a useful logical operator for contracts.

Package

quid-pro-quo

Source

utilities.lisp (file)

Macro: old EXPRESSION

Only available in postconditions, OLD evaluates its expression before the primary method is executed and stores it for use in the postcondition.

Package

quid-pro-quo

Source

method-combination.lisp (file)

Macro: with-contracts-disabled () &body BODY

A shorthand for disabling all contracts for the extent of this form.

Package

quid-pro-quo

Source

method-combination.lisp (file)

Macro: with-contracts-enabled (&rest ARGS &key INVARIANTS PRECONDITIONS POSTCONDITIONS) &body BODY

Enables/disables contracts for the extent of this form, restoring them to their prior values upon exit.

Package

quid-pro-quo

Source

method-combination.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: add-invariant FUNCTION-NAME DESCRIPTION LAMBDA-LIST SPECIALIZERS LAMBDA-BODY

Adds an invariant to the provided generic function.

Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: disable-contracts ()

A shorthand for disabling all contracts.

Package

quid-pro-quo

Source

method-combination.lisp (file)

Function: enable-contracts &key INVARIANTS PRECONDITIONS POSTCONDITIONS

Enables or disables each contract type that is provided. If none is provided, no change is made.

Package

quid-pro-quo

Source

method-combination.lisp (file)

Function: passes-invariants-p OBJECT

This checks that an instance passes all the class invariants.

Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: results ()

This is really only available to postconditions. It returns the values returned by the primary/around method, so they can be checked in the postcondition.

Package

quid-pro-quo

Source

method-combination.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Method combinations

Long Method Combination: contract ()

This method combination extends the STANDARD method combination by adding :REQUIRE and :GUARANTEE methods for pre- and postconditions, respectively. It also provides invariants, which are created automatically on slot-accessors for classes that use the CONTRACTED-CLASS metaclass. Invariant methods should not be created explicitly.

Package

quid-pro-quo

Source

method-combination.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Conditions

Condition: after-invariant-error ()

This invariant-error is signaled when the invariant fails when checked after a call.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

invariant-error (condition)

Condition: before-invariant-error ()

This invariant-error is signaled when the invariant fails when checked before a call.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

invariant-error (condition)

Condition: contract-violation-error ()

This is the superclass of all contract violations.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct subclasses
Direct slots
Slot: failed-check
Initargs

:failed-check

Slot: arguments
Initargs

:arguments

Slot: description
Initargs

:description

Initform

(quote nil)

Condition: creation-invariant-error ()

This invariant-error is signaled when the invariant fails upon object creation.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

invariant-error (condition)

Condition: invariant-error ()

This error is signaled whenever an invariant fails. It is the class’s responisibility to fix whatever is wrong.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

contract-violation-error (condition)

Direct subclasses
Direct slots
Slot: object
Initargs

:object

Initform

(quote nil)

Condition: malformed-contract-warning ()

This warning is signaled when some discrepancy is identified in the contract itself.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

warning (condition)

Direct subclasses

overly-strict-precondition-warning (condition)

Direct slots
Slot: function
Initargs

:function

Slot: arguments
Initargs

:arguments

Slot: description
Initargs

:description

Initform

(quote nil)

Condition: overly-strict-precondition-warning ()

If there are multiple preconditions methods on a function, this warning is signaled when a more specific method is more restrictive than a less specific method. Preconditions may only remove restrictions as they get more specific.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

malformed-contract-warning (condition)

Direct slots
Slot: more-strict-method
Initargs

:more-strict-method

Slot: less-strict-method
Initargs

:less-strict-method

Condition: postcondition-error ()

This error is signaled whenever a postcondition fails. It is the callee’s responsibility to fix whatever is wrong.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

contract-violation-error (condition)

Direct slots
Slot: results
Initargs

:results

Condition: precondition-error ()

This error is signaled when a precondition fails. It is the caller’s responsibility to fix whatever went wrong.

Package

quid-pro-quo

Source

conditions.lisp (file)

Direct superclasses

contract-violation-error (condition)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.6 Classes

Class: contracted-class ()

This is the metaclass for any classes you want to add invariants to.

Package

quid-pro-quo

Source

metaclass.lisp (file)

Direct superclasses

standard-class (class)

Direct subclasses

funcallable-contracted-class (class)

Direct methods
Direct slots
Slot: invariants
Initargs

:invariants

Readers

direct-class-invariants (generic function)

Slot: invariant-descriptions
Class: funcallable-contracted-class ()

This is the metaclass for any funcallable classes you want to add invariants to.

Package

quid-pro-quo

Source

metaclass.lisp (file)

Direct superclasses

Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: %results

Holds a list of values, accessed by the RESULTS function.

Package

quid-pro-quo

Source

method-combination.lisp (file)

Special Variable: *check-invariants-p*
Package

quid-pro-quo

Source

method-combination.lisp (file)

Special Variable: *check-postconditions-p*
Package

quid-pro-quo

Source

method-combination.lisp (file)

Special Variable: *check-preconditions-p*
Package

quid-pro-quo

Source

method-combination.lisp (file)

Special Variable: *contract-method-combination*
Package

quid-pro-quo

Source

method-combination.lisp (file)

Special Variable: *inside-contract-p*
Package

quid-pro-quo

Source

method-combination.lisp (file)

Special Variable: *postcondition-values*

This contains all the values computed for the current set of postconditions

Package

quid-pro-quo

Source

method-combination.lisp (file)

Special Variable: *preparing-postconditions*

This is true when we are setting up postconditions by pre-evaluating any forms that need an OLD value.

Package

quid-pro-quo

Source

method-combination.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: defcontract NAME TYPE LAMBDA-LIST &body BODY

This macro makes it possible to add pre- and postconditions to non-generic functions as well.

Package

quid-pro-quo

Source

sbcl-encapsulate.lisp (file)

Macro: sb-encapsulate NAME IDENTIFIER FDEFN ARGLIST &body BODY
Package

quid-pro-quo

Source

sbcl-encapsulate.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: add-accessor-invariants CLASS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: add-reader-invariant READER CLASS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: add-writer-invariant WRITER CLASS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: all-direct-slots CLASS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: description CONDITION
Package

quid-pro-quo

Source

conditions.lisp (file)

Function: description<-remaining-forms REMAINING-FORMS
Package

quid-pro-quo

Source

macros.lisp (file)

Function: enabled-contracts ()

Returns a list of arguments suitable to APPLYing to ENABLE-CONTRACTS.

Package

quid-pro-quo

Source

method-combination.lisp (file)

Function: ensure-contracted-function FUNCTION-NAME LAMBDA-LIST

This both ensures that the method combination is correct as well as that the correct version of STANDARD-GENERIC-FUNCTION is used (for some implementations, Closer-MOP’s STANDARD-GENERIC-FUNCTION is different from CL’s).

Package

quid-pro-quo

Source

macros.lisp (file)

Function: initialize-invariants INSTANCE INVARIANTS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: invariant-description CLASS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: passes-class-invariants-p OBJECT
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: passes-slot-type-invariants-p OBJECT
Package

quid-pro-quo

Source

metaclass.lisp (file)

Function: strip-lambda-list LL
Package

quid-pro-quo

Source

macros.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: class-invariant-descriptions CLASS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Methods
Method: class-invariant-descriptions (CLASS contracted-class)
Method: class-invariant-descriptions CLASS
Generic Function: class-invariants CLASS
Package

quid-pro-quo

Source

metaclass.lisp (file)

Methods
Method: class-invariants (CLASS contracted-class)
Method: class-invariants CLASS
Generic Function: direct-class-invariants OBJECT
Package

quid-pro-quo

Methods
Method: direct-class-invariants (CONTRACTED-CLASS contracted-class)

automatically generated reader method

Source

metaclass.lisp (file)

Generic Function: function-name CHECK
Package

quid-pro-quo

Source

conditions.lisp (file)

Methods
Method: function-name (CHECK method)
Method: function-name (CHECK function)

Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   Q  
Index Entry  Section

F
File, Lisp, quid-pro-quo.asd: The quid-pro-quo<dot>asd file
File, Lisp, quid-pro-quo/conditions.lisp: The quid-pro-quo/conditions<dot>lisp file
File, Lisp, quid-pro-quo/macros.lisp: The quid-pro-quo/macros<dot>lisp file
File, Lisp, quid-pro-quo/metaclass.lisp: The quid-pro-quo/metaclass<dot>lisp file
File, Lisp, quid-pro-quo/method-combination.lisp: The quid-pro-quo/method-combination<dot>lisp file
File, Lisp, quid-pro-quo/package.lisp: The quid-pro-quo/package<dot>lisp file
File, Lisp, quid-pro-quo/sbcl-encapsulate.lisp: The quid-pro-quo/sbcl-encapsulate<dot>lisp file
File, Lisp, quid-pro-quo/system-connections.lisp: The quid-pro-quo/system-connections<dot>lisp file
File, Lisp, quid-pro-quo/utilities.lisp: The quid-pro-quo/utilities<dot>lisp file

L
Lisp File, quid-pro-quo.asd: The quid-pro-quo<dot>asd file
Lisp File, quid-pro-quo/conditions.lisp: The quid-pro-quo/conditions<dot>lisp file
Lisp File, quid-pro-quo/macros.lisp: The quid-pro-quo/macros<dot>lisp file
Lisp File, quid-pro-quo/metaclass.lisp: The quid-pro-quo/metaclass<dot>lisp file
Lisp File, quid-pro-quo/method-combination.lisp: The quid-pro-quo/method-combination<dot>lisp file
Lisp File, quid-pro-quo/package.lisp: The quid-pro-quo/package<dot>lisp file
Lisp File, quid-pro-quo/sbcl-encapsulate.lisp: The quid-pro-quo/sbcl-encapsulate<dot>lisp file
Lisp File, quid-pro-quo/system-connections.lisp: The quid-pro-quo/system-connections<dot>lisp file
Lisp File, quid-pro-quo/utilities.lisp: The quid-pro-quo/utilities<dot>lisp file

Q
quid-pro-quo.asd: The quid-pro-quo<dot>asd file
quid-pro-quo/conditions.lisp: The quid-pro-quo/conditions<dot>lisp file
quid-pro-quo/macros.lisp: The quid-pro-quo/macros<dot>lisp file
quid-pro-quo/metaclass.lisp: The quid-pro-quo/metaclass<dot>lisp file
quid-pro-quo/method-combination.lisp: The quid-pro-quo/method-combination<dot>lisp file
quid-pro-quo/package.lisp: The quid-pro-quo/package<dot>lisp file
quid-pro-quo/sbcl-encapsulate.lisp: The quid-pro-quo/sbcl-encapsulate<dot>lisp file
quid-pro-quo/system-connections.lisp: The quid-pro-quo/system-connections<dot>lisp file
quid-pro-quo/utilities.lisp: The quid-pro-quo/utilities<dot>lisp file

Jump to:   F   L   Q  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   A   C   D   E   F   G   I   M   O   P   R   S   W  
Index Entry  Section

A
add-accessor-invariants: Internal functions
add-invariant: Exported functions
add-reader-invariant: Internal functions
add-writer-invariant: Internal functions
all-direct-slots: Internal functions

C
class-invariant-descriptions: Internal generic functions
class-invariant-descriptions: Internal generic functions
class-invariant-descriptions: Internal generic functions
class-invariants: Internal generic functions
class-invariants: Internal generic functions
class-invariants: Internal generic functions

D
defcontract: Internal macros
defguarantee: Exported macros
defrequirement: Exported macros
description: Internal functions
description<-remaining-forms: Internal functions
direct-class-invariants: Internal generic functions
direct-class-invariants: Internal generic functions
disable-contracts: Exported functions

E
enable-contracts: Exported functions
enabled-contracts: Internal functions
ensure-contracted-function: Internal functions

F
Function, add-accessor-invariants: Internal functions
Function, add-invariant: Exported functions
Function, add-reader-invariant: Internal functions
Function, add-writer-invariant: Internal functions
Function, all-direct-slots: Internal functions
Function, description: Internal functions
Function, description<-remaining-forms: Internal functions
Function, disable-contracts: Exported functions
Function, enable-contracts: Exported functions
Function, enabled-contracts: Internal functions
Function, ensure-contracted-function: Internal functions
Function, initialize-invariants: Internal functions
Function, invariant-description: Internal functions
Function, passes-class-invariants-p: Internal functions
Function, passes-invariants-p: Exported functions
Function, passes-slot-type-invariants-p: Internal functions
Function, results: Exported functions
Function, strip-lambda-list: Internal functions
function-name: Internal generic functions
function-name: Internal generic functions
function-name: Internal generic functions

G
Generic Function, class-invariant-descriptions: Internal generic functions
Generic Function, class-invariants: Internal generic functions
Generic Function, direct-class-invariants: Internal generic functions
Generic Function, function-name: Internal generic functions

I
implies: Exported macros
initialize-invariants: Internal functions
invariant-description: Internal functions

M
Macro, defcontract: Internal macros
Macro, defguarantee: Exported macros
Macro, defrequirement: Exported macros
Macro, implies: Exported macros
Macro, old: Exported macros
Macro, sb-encapsulate: Internal macros
Macro, with-contracts-disabled: Exported macros
Macro, with-contracts-enabled: Exported macros
Method, class-invariant-descriptions: Internal generic functions
Method, class-invariant-descriptions: Internal generic functions
Method, class-invariants: Internal generic functions
Method, class-invariants: Internal generic functions
Method, direct-class-invariants: Internal generic functions
Method, function-name: Internal generic functions
Method, function-name: Internal generic functions

O
old: Exported macros

P
passes-class-invariants-p: Internal functions
passes-invariants-p: Exported functions
passes-slot-type-invariants-p: Internal functions

R
results: Exported functions

S
sb-encapsulate: Internal macros
strip-lambda-list: Internal functions

W
with-contracts-disabled: Exported macros
with-contracts-enabled: Exported macros

Jump to:   A   C   D   E   F   G   I   M   O   P   R   S   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   %   *  
A   D   F   I   L   M   O   R   S  
Index Entry  Section

%
%results: Internal special variables

*
*check-invariants-p*: Internal special variables
*check-postconditions-p*: Internal special variables
*check-preconditions-p*: Internal special variables
*contract-method-combination*: Internal special variables
*inside-contract-p*: Internal special variables
*invariant-initializers*: Exported special variables
*postcondition-values*: Internal special variables
*preparing-postconditions*: Internal special variables
*verify-preconditions-p*: Exported special variables

A
arguments: Exported conditions
arguments: Exported conditions

D
description: Exported conditions
description: Exported conditions

F
failed-check: Exported conditions
function: Exported conditions

I
invariant-descriptions: Exported classes
invariants: Exported classes

L
less-strict-method: Exported conditions

M
more-strict-method: Exported conditions

O
object: Exported conditions

R
results: Exported conditions

S
Slot, arguments: Exported conditions
Slot, arguments: Exported conditions
Slot, description: Exported conditions
Slot, description: Exported conditions
Slot, failed-check: Exported conditions
Slot, function: Exported conditions
Slot, invariant-descriptions: Exported classes
Slot, invariants: Exported classes
Slot, less-strict-method: Exported conditions
Slot, more-strict-method: Exported conditions
Slot, object: Exported conditions
Slot, results: Exported conditions
Special Variable, %results: Internal special variables
Special Variable, *check-invariants-p*: Internal special variables
Special Variable, *check-postconditions-p*: Internal special variables
Special Variable, *check-preconditions-p*: Internal special variables
Special Variable, *contract-method-combination*: Internal special variables
Special Variable, *inside-contract-p*: Internal special variables
Special Variable, *invariant-initializers*: Exported special variables
Special Variable, *postcondition-values*: Internal special variables
Special Variable, *preparing-postconditions*: Internal special variables
Special Variable, *verify-preconditions-p*: Exported special variables

Jump to:   %   *  
A   D   F   I   L   M   O   R   S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   F   I   L   M   O   P   Q   S  
Index Entry  Section

A
after-invariant-error: Exported conditions

B
before-invariant-error: Exported conditions

C
Class, contracted-class: Exported classes
Class, funcallable-contracted-class: Exported classes
Condition, after-invariant-error: Exported conditions
Condition, before-invariant-error: Exported conditions
Condition, contract-violation-error: Exported conditions
Condition, creation-invariant-error: Exported conditions
Condition, invariant-error: Exported conditions
Condition, malformed-contract-warning: Exported conditions
Condition, overly-strict-precondition-warning: Exported conditions
Condition, postcondition-error: Exported conditions
Condition, precondition-error: Exported conditions
contract: Exported method combinations
contract-violation-error: Exported conditions
contracted-class: Exported classes
creation-invariant-error: Exported conditions

F
funcallable-contracted-class: Exported classes

I
invariant-error: Exported conditions

L
Long Method Combination, contract: Exported method combinations

M
malformed-contract-warning: Exported conditions
Method Combination, Long, contract: Exported method combinations

O
overly-strict-precondition-warning: Exported conditions

P
Package, quid-pro-quo: The quid-pro-quo package
Package, quid-pro-quo.system: The quid-pro-quo<dot>system package
postcondition-error: Exported conditions
precondition-error: Exported conditions

Q
quid-pro-quo: The quid-pro-quo system
quid-pro-quo: The quid-pro-quo package
quid-pro-quo.system: The quid-pro-quo<dot>system package

S
System, quid-pro-quo: The quid-pro-quo system

Jump to:   A   B   C   F   I   L   M   O   P   Q   S