8.8 Contract Utilities
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.
if its argument is a contract that guarantees that
it returns a value which passes chaperone-of?
when compared to
the original, uncontracted value.
Returns #t if its argument is a contract that is not a chaperone
contract nor a flat contract.
Returns #t when its argument is a contract that can be
checked immediately (unlike, say, a function contract).
flat-contract constructs flat contracts from predicates, and
symbols, booleans, numbers, and other ordinary Racket values
(that are defined as contracts) are also
Produces the name used to describe the contract in error messages.
Returns the contract attached to v, if recorded.
Otherwise it returns #f.
To support value-contract and has-contract?
in your own contract combinators, use prop:contracted or
Returns #t if v is a value that
has a recorded contract attached to it.
See also value-contract.
Produces the projection defining a contract’s behavior on protected values.
Makes a contract that accepts no values, and reports the
name sexp-name when signaling a contract violation.
Delays the evaluation of its argument until the contract is checked,
making recursive contracts possible. If type is given, it
describes the expected type of contract and must be one of the keywords
#:impersonator, #:chaperone, or #:flat. If
type is not given, an impersonator contract is created.
(opt/c contract-expr maybe-name)
|maybe-name|| ||=|| |
| || ||||| ||#:error-name id|
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 overhead as possible. The result is a
contract that should behave identically to its argument,
If the #:error-name argument is present, and
contract-expr evaluates to a non-contract
expression, then opt/c raises an error using
id as the name of the primitive, instead of using
the name opt/c.
opt/c: contract violation
define/contract: contract violation
This defines a recursive contract and simultaneously
optimizes it. Semantically, it behaves just as if
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
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.