► |  | Reference: PLT Scheme

1 | Language Model
2 | Syntactic Forms
3 | Datatypes
4 | Structures
5 | Classes and Objects
6 | Units
7 | Contracts
8 | Pattern Matching
9 | Control Flow
10 | Concurrency
11 | Macros
12 | Input and Output
13 | Reflection and Security
14 | Operating System
15 | Memory Management
16 | Unsafe Operations
17 | Running PLT Scheme
| Bibliography
| Index

▼ | 7 | Contracts

7.1 | Data-structure Contracts
7.2 | Function Contracts
7.3 | Lazy Data-structure Contracts
7.4 | Attaching Contracts to Values
7.5 | Building New Contract Combinators
7.6 | Contract Utilities

On this page:

guilty-party
contract?
flat-contract?
flat-contract-predicate
contract-first-order-passes?
make-none/ c
contract-violation->string
recursive-contract
opt/ c
define-opt/ c

top← prev up next →

#### 7.6`` Contract Utilities

(guilty-party exn) → any
exn : exn?

Extracts the name of the guilty party from an exception raised by the contract system.

(contract? v) → boolean?
v : any/c

Returns #t if its argument is a contract (i.e., constructed with one of the combinators described in this section or a value that can be used as a contract) and #f otherwise.

(flat-contract? v) → boolean?
v : any/c

Returns #t when its argument is a contract that can be checked immediately (unlike, say, a function contract).

For example, flat-contract constructs flat contracts from predicates, and symbols, booleans, numbers, and other ordinary Scheme values (that are defined as contracts) are also flat contracts.

(flat-contract-predicate v) → (any/c . -> . any/c)
v : flat-contract?

Extracts the predicate from a flat contract.

(contract-first-order-passes? contract v) → boolean?
contract : contract?
v : any/c

Returns a boolean indicating if the first-order tests of contract pass for v.

If it returns #f, the contract is guaranteed not to hold for that value; if it returns #t, the contract may or may not hold. If the contract is a first-order contract, a result of #t guarantees that the contract holds.

(make-none/c sexp-name) → contract?
sexp-name : any/c

Makes a contract that accepts no values, and reports the name sexp-name when signaling a contract violation.

(contract-violation->string)
→ (-> any/c any/c (or/c #f any/c) any/c string? string?)
(contract-violation->string proc) → void?
proc : (-> any/c any/c (or/c #f any/c) any/c string? string?)

This is a parameter that is used when constructing a contract violation error. Its value is procedure that accepts five arguments:

- the value that the contract applies to,

- a syntax object representing the source location where the contract was established,

- the name of the party that violated the contract (#f indicates that the party is not known, not that the party’s name is #f),

- an sexpression representing the contract, and

- a message indicating the kind of violation.

The procedure then returns a string that is put into the contract error message. Note that the value is often already included in the message that indicates the violation.

If the contract was establised via provide/contract, the names of the party to the contract will be sexpression versions of the module paths (as returned by collapse-module-path).

(recursive-contract contract-expr)

Delays the evaluation of its argument until the contract is checked, making recursive contracts possible.

(opt/c contract-expr)

This optimizes its argument contract expression by traversing its syntax and, for known contract combinators, fuses them into a single contract combinator that avoids as much allocation overhad as possible. The result is a contract that should behave identically to its argument, except faster (due to the less allocation).

(define-opt/c (id id ...) expr)

This defines a recursive contract and simultaneously optimizes it. Semantically, it behaves just as if the -opt/c were not present, defining a function on contracts (except that the body expression must return a contract). But, it also optimizes that contract definition, avoiding extra allocation, much like opt/c does.

For example,

(define-contract-struct bt (val left right))
(define-opt/c (bst-between/c lo hi)
(or/c null?
(bt/c [val (real-in lo hi)]
[left (val) (bst-between/c lo val)]
[right (val) (bst-between/c val hi)])))
(define bst/c (bst-between/c -inf.0 +inf.0))

defines the bst/c contract that checks the binary search tree invariant. Removing the -opt/c also makes a binary search tree contract, but one that is (approximately) 20 times slower.

top← prev up next →