Version: 4.2.1
7.1 Data-structure Contracts
A flat contract can be fully checked immediately for
a given value.
Constructs a
flat contract from
predicate. A value
satisfies the contract if the predicate returns a true value.
Like
flat-contract, but the first argument must be the
(quoted) name of a contract used for error reporting.
For example,
turns the predicate into a contract with the name odd-integer.
A flat contract that accepts any value.
When using this contract as the result portion of a function contract,
consider using any instead; using any leads to
better memory performance, but it also allows multiple results.
Takes any number of contracts and returns
a contract that accepts any value that any one of the contracts
accepts, individually.
The or/c result tests any value by applying the contracts in
order, from left to right, with the exception that it always moves the
non-flat contracts (if any) to the end, checking them
last. Thus, a contract such as (or/c (not/c real?) positive?) is guaranteed to only invoke the positive?
predicate on real numbers.
If all of the arguments are procedures or flat contracts, the
result is a flat contract. If only one of the arguments is a
higher-order contract, the result is a contract that just checks the
flat contracts and, if they don’t pass, applies the higher-order
contract.
If there are multiple higher-order contracts,
or/c uses
contract-first-order-passes? to distinguish between
them. More precisely, when an
or/c is checked, it first
checks all of the
flat contracts. If none of them pass, it
calls
contract-first-order-passes? with each of the
higher-order contracts. If only one returns true,
or/c uses
that contract. If none of them return true, it signals a contract
violation. If more than one returns true, it also signals a contract
violation.
For example, this contract
does not accept a function like this one:
(lambda args ...)
since it cannot tell which of the two arrow contracts should be used
with the function.
Takes any number of contracts and returns a contract that checks that
accepts any value that satisfies all of the contracts, simultaneously.
If all of the arguments are procedures or flat contracts,
the result is a flat contract.
The contract produced by and/c tests any value by applying
the contracts in order, from left to right.
Accepts a flat contracts or a predicate and returns a flat contract
that checks the inverse of the argument.
Returns a flat contract that requires the input to be a number and
= to
z.
Returns a flat contract that requires the input to be a number and
< to
n.
Returns a flat contract that requires the
input to be a between n and m or equal to
one of them.
Returns a flat contract that requires the input to be a real number
between n and m, inclusive.
Returns a flat contract that requires the input to be an exact integer
between j and k, inclusive.
A flat contract that requires the input to be an exact non-negative integer.
Returns a flat contract that recognizes strings that have fewer than
len characters.
This is just #f. It is here for backwards compatibility.
A flat contract that recognizes values that can be written out and
read back in with
write and
read.
Accepts any number of atomic values and returns a flat contract that
recognizes those values, using
eqv? as the comparison
predicate. For the purposes of
one-of/c, atomic values are
defined to be: characters, symbols, booleans, null keywords, numbers,
void, and undefined.
Accepts any number of symbols and returns a flat contract that
recognizes those symbols.
Accepts a
flat contract (or a predicate that is converted to a
flat contract via
flat-contract) and returns a flat contract
that checks for vectors whose elements match the original contract.
Like
vectorof, but the contract needs not be a
flat
contract. Beware that when this contract is applied to a
value, the result is not
eq? to the input.
Accepts any number of flat contracts (or predicates that are converted
to flat contracts via
flat-contract) and returns a
flat-contract that recognizes vectors. The number of elements in the
vector must match the number of arguments supplied to
vector/c, and each element of the vector must match the
corresponding flat contract.
Like
vector/c, but the individual contracts need not be
flat contracts. Beware that when this contract is applied to a
value, the result is not
eq? to the input.
Returns a flat-contract that recognizes boxes. The content of the box
must match c.
Like
box/c, but
c need not be
flat
contract. Beware that when this contract is applied to a value, the
result is not
eq? to the input.
Returns a contract that recognizes a list whose every element matches
the contract
c. Beware that when this contract is applied to
a value, the result is not necessarily
eq? to the input.
Produces a contract the recognizes pairs first and second elements
match
car-c and
cdr-c, respectively. Beware that
when this contract is applied to a value, the result is not
necessarily
eq? to the input.
Produces a contract for a list. The number of elements in the list
must match the number of arguments supplied to
list/c, and
each element of the list must match the corresponding contract. Beware
that when this contract is applied to a value, the result is not
necessarily
eq? to the input.
Produces a flat contract that recognizes syntax objects whose
syntax-e content matches
c.
| (struct/c struct-id flat-contract-expr ...) |
Produces a flat contract that recognizes instances of the structure
type named by
struct-id, and whose field values match the
flat contracts produced by the
flat-contract-exprs.
Produces a contract on parameters whose values must match
contract.
Produces a contract that recognizes hash tables with keys and values
as specified by the key and val arguments.
If the immutable argument is #f or
'dont-care, then the resulting contract is a flat contract,
and the key and val arguments must also be flat
contracts.
If immtable is #t, then the other arguments do not
have to be flat contracts, the result is not a flat contract, and
checking this contract involves making a copy of the hash-table.
Constructs a recursive flat contract. A
flat-contract-expr can refer to id to refer
recursively to the generated contract.
For example, the contract
is a flat contract that checks for (a limited form of)
S-expressions. It says that an sexp is either two
sexp combined with cons, or a number, or a symbol.
Note that if the contract is applied to a circular value, contract
checking will not terminate.}
A generalization of
flat-rec-contract for defining several
mutually recursive flat contracts simultaneously. Each
id is
visible in the entire
flat-murec-contract form, and the
result of the final
body is the result of the entire form.
Represents a contract that is always satisfied. In particular, it can accept
multiple values. It can only be used in a result position of contracts like
->. Using
any elsewhere is a syntax error.
Constructs a contract on a promise. The contract does not force the
promise, but when the promise is forced, the contract checks that the
result value meets the contract produced by expr.