(
:string
⟨
var
⟩
⟨
arg1
⟩
⟨
arg2
⟩
...
)
⟹
generator-macro
(
:string
⟨
var1
⟩
(
index
⟨
var2
⟩
)
⟨
arg1
⟩
⟨
arg2
⟩
...
)
⟹
generator-macro

(
:until
⟨
generator
⟩
⟨
expression
⟩
)
⟹
generator-macro

generator
⟹
generator-macro

(
:vector
⟨
var
⟩
⟨
arg1
⟩
⟨
arg2
⟩
...
)
⟹
generator-macro
(
:vector
⟨
var1
⟩
(
index
⟨
var2
⟩
)
⟨
arg1
⟩
⟨
arg2
⟩
...
)
⟹
generator-macro

(
:while
⟨
generator
⟩
⟨
expression
⟩
)
⟹
generator-macro

generator
⟹
generator-macro

=, <, >, <=, >= These procedures return #t if their arguments are (respectively): equal, monotonically increasing, monotonically decreasing, monotonically non-decreasing, or monotonically non-increasing, and #f otherwise. If any of the arguments are +nan.0, all the predicates return #f. They do not distinguish between inexact zero and inexact negative zero. These predicates are transitive. Note: While it is not an error to compare inexact numbers using these predicates, the results are unreliable because a small inaccuracy can affect the result; this is especially true of = and zero?. When in doubt, consult a numerical analyst.

(
</<=?
)
⟹
procedure?
(
</<=?
[
procedure?
compare
]
)
⟹
procedure?
(
</<=?
x
y
z
)
⟹
boolean?
(
</<=?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
</<?
)
⟹
procedure?
(
</<?
[
procedure?
compare
]
)
⟹
procedure?
(
</<?
x
y
z
)
⟹
boolean?
(
</<?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
<=/<=?
)
⟹
procedure?
(
<=/<=?
[
procedure?
compare
]
)
⟹
procedure?
(
<=/<=?
x
y
z
)
⟹
boolean?
(
<=/<=?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
<=/<?
)
⟹
procedure?
(
<=/<?
[
procedure?
compare
]
)
⟹
procedure?
(
<=/<?
x
y
z
)
⟹
boolean?
(
<=/<?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
<=?
)
⟹
procedure?
(
<=?
[
procedure?
compare
]
)
⟹
procedure?
(
<=?
x
y
)
⟹
boolean?
(
<=?
[
procedure?
compare
]
x
y
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
<=?
[
comparator?
comparator
]
object1
object2
object3
...
)
⟹
boolean?

=?, <?, >?, <=?, >=? These procedures are analogous to the number, character, and string comparison predicates of Scheme. They allow the convenient use of comparators to handle variable data types.
These procedures apply the equality and ordering predicates of comparator to the objects as follows. If the specified relation returns #t for all objecti and objectj where n is the number of objects and 1 <= i < j <= n, then the procedures return #t, but otherwise #f. Because the relations are transitive, it suffices to compare each object with its successor. The order in which the values are compared is unspecified.

(
<?
)
⟹
procedure?
(
<?
[
procedure?
compare
]
)
⟹
procedure?
(
<?
x
y
)
⟹
boolean?
(
<?
[
procedure?
compare
]
x
y
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
<?
[
comparator?
comparator
]
object1
object2
object3
...
)
⟹
boolean?

(
=?
)
⟹
procedure?
(
=?
[
procedure?
compare
]
)
⟹
procedure?
(
=?
x
y
)
⟹
boolean?
(
=?
[
procedure?
compare
]
x
y
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
=?
[
comparator?
comparator
]
object1
object2
object3
...
)
⟹
boolean?

(
>/>=?
)
⟹
procedure?
(
>/>=?
[
procedure?
compare
]
)
⟹
procedure?
(
>/>=?
x
y
z
)
⟹
boolean?
(
>/>=?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
>/>?
)
⟹
procedure?
(
>/>?
[
procedure?
compare
]
)
⟹
procedure?
(
>/>?
x
y
z
)
⟹
boolean?
(
>/>?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
>=/>=?
)
⟹
procedure?
(
>=/>=?
[
procedure?
compare
]
)
⟹
procedure?
(
>=/>=?
x
y
z
)
⟹
boolean?
(
>=/>=?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
>=/>?
)
⟹
procedure?
(
>=/>?
[
procedure?
compare
]
)
⟹
procedure?
(
>=/>?
x
y
z
)
⟹
boolean?
(
>=/>?
[
procedure?
compare
]
x
y
z
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
>=?
)
⟹
procedure?
(
>=?
[
procedure?
compare
]
)
⟹
procedure?
(
>=?
x
y
)
⟹
boolean?
(
>=?
[
procedure?
compare
]
x
y
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
>=?
[
comparator?
comparator
]
object1
object2
object3
...
)
⟹
boolean?

(
>?
)
⟹
procedure?
(
>?
[
procedure?
compare
]
)
⟹
procedure?
(
>?
x
y
)
⟹
boolean?
(
>?
[
procedure?
compare
]
x
y
)
⟹
boolean?

compare
⟹
(
λ
x
y
)
⟹
integer?

(
>?
[
comparator?
comparator
]
object1
object2
object3
...
)
⟹
boolean?

The abs procedure returns the absolute value of its argument.