The primitive type predicate for type inert.
inert?returns true iff all the objects in
objectsare of type inert.
$ifoperative first evaluates
<test>in the dynamic environment. If the result is not of type boolean, an error is signaled. If the result is true,
<consequent>is then evaluated in the dynamic environment as a tail context. Otherwise,
<alternative>is evaluated in the dynamic environment as a tail context.
$sequenceoperative evaluates the elements of the list
<objects>in the dynamic environment, one at a time from left to right. If
<objects>is a cyclic list, element evaluation continues indefinitely, with elements in the cycle being evaluated repeatedly. If
<objects>is a nonempty finite list, its last element is evaluated as a tail context. If
<objects>is the empty list, the result is inert.
<clauses>should be a list of clause expressions, each of the form
(<test> . <body>), where body is a list of expressions.
The following equivalences define the behaviour of the
$condoperative:($cond) == #inert ($cond (<test> . <body>) . <clauses>) == ($if <test> ($sequence . <body>) ($cond . <clauses>))
listsmust be a nonempty list of lists; if there are two or more, they should all be the same length. If lists is empty, or if all of its elements are not lists of the same length, an error is signaled.
for-eachbehaves identically to
map, except that instead of accumulating and returning a list of the results of the element-wise applications, the results of the applications are discarded and the result returned by
— Applicative: vector-for-each (vector-for-each applicative. vectors)
— Applicative: bytevector-for-each (bytevector-for-each applicative . bytevectors)
bytevectorsshould be non-empty lists of the corresponding type and all elements should be of the same length.
These applicatives behave as
for-eachexcept that the list of elements passed to
applicativeare the n-th chars, objects, or uint8s of the strings, vectors or bytevectors passed as arguments.
SOURCE NOTE: These are taken from r7rs.
— Operative: $unless ($unless <test> . <body>)
bodyshould be a list of expressions.
These operatives behave as one-armed
$ifs with an implicit
$sequence, except that they always discard the last value and the result returned is inert.
<test>in the dynamic environment. If the result is non boolean an error is signaled. In
$whenif the result is false and in
$unlessif the result is true, the expressions in
<body>are not evaluated and an inert value is returned. Otherwise, the expressions in
<body>are evaluated sequentially in the dynamic environment. If
<body>is a non cyclic list, the last expression in
<body>is evaluated in a special type of tail context, that, upon receiving a value discards it and returns an inert value instead. If
<body>is a cyclic list, element evaluation continues indefinitely, with elements in the cycle being evaluated repeatedly. SOURCE NOTE: These are taken from r7rs.