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.
On predicates 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.
On flat contracts, the new flat contract is the same as the old except for
the name.
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.
Returns a contract that recognizes non-empty lists whose elements match
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 immutable 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.
Constructs a new existential contract.
Existential contracts accept all values when in positive positions (e.g., function
returns) and wraps the value in an opaque struct, hiding the precise value.
In negative positions (e.g. function inputs),
it accepts only values that were previously accepted in negative positions (by checking
for the wrappers).
For example, this contract:
describes a function that accepts the identity function (or a non-terminating function)
and returns an arbitrary value. That is, the first use of the a appears in a
positive position and thus inputs to that function are wrapped with an opaque struct.
Then, when the function returns, it is checked to see if the result is wrapped, since
the second a appears in a negative position.