# Search

( * [ number? z ] ... )
This procedure returns the product of its arguments.
( * [ number? z ] ... )
This procedure returns the product of its arguments.
( + [ number? z ] ... )
This procedure returns the sum of its arguments.
( + [ number? z ] ... )
This procedure returns the sum of its arguments.
( - [ number? z ] ... )
With two or more arguments, this procedure returns the difference of its arguments, associating to the left. With one argument, however, it returns the additive inverse of its argument.
( - [ number? z ] ... )
With two or more arguments, this procedure returns the difference of its arguments, associating to the left. With one argument, however, it returns the additive inverse of its argument.
( / [ number? z1 ] [ number? z2 ] ... )
With two or more arguments, this procedure returns the quotient of its arguments, associating to the left. With one argument, however, it returns multiplicative inverse of its argument. It is an error if any argument of / other than the first is an exact zero. If the first argument is an exact zero, an implementation may return an exact zero unless one of the other arguments is a NaN.
( / [ number? z1 ] [ number? z2 ] ... )
With two or more arguments, this procedure returns the quotient of its arguments, associating to the left. With one argument, however, it returns the multiplicative inverse of its argument.
( < [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically increasing, and #f otherwise. If any of the arguments are +nan.0, predicate returns #f. It does not distinguish between inexact zero and inexact negative zero. The predicate is transitive. Note: While it is not an error to compare inexact numbers using this predicate, the results are unreliable because a small inaccuracy can affect the result. When in doubt, consult a numerical analyst.
( < [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically increasing.
( <= [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically non-decreasing.
( <= [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically non-decreasing, and #f otherwise. If any of the arguments are +nan.0, predicate returns #f. It does not distinguish between inexact zero and inexact negative zero. The predicate is transitive. Note: While it is not an error to compare inexact numbers using this predicate, the results are unreliable because a small inaccuracy can affect the result. When in doubt, consult a numerical analyst.
( = [ number? z1 ] [ number? z2 ] [ number? z3 ] ... )
This procedure returns #t if its arguments are equal, and #f otherwise. If any of the arguments are +nan.0, the predicate return #f. It does not distinguish between inexact zero and inexact negative zero. This predicate is transitive. Note: While it is not an error to compare inexact numbers using this predicate, the results are unreliable because a small inaccuracy can affect the result; this is especially true of =. When in doubt, consult a numerical analyst.
( > [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically decreasing.
( > [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically decreasing, and #f otherwise. If any of the arguments are +nan.0, predicate returns #f. It does not distinguish between inexact zero and inexact negative zero. The predicate is transitive. Note: While it is not an error to compare inexact numbers using this predicate, the results are unreliable because a small inaccuracy can affect the result. When in doubt, consult a numerical analyst.
( >= [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically non-increasing.
( >= [ real? x1 ] [ real? x2 ] [ real? x3 ] ... )
This procedure returns #t if its arguments are monotonically non-increasing, and #f otherwise. If any of the arguments are +nan.0, predicate returns #f. It does not distinguish between inexact zero and inexact negative zero. The predicate is transitive. Note: While it is not an error to compare inexact numbers using this predicate, the results are unreliable because a small inaccuracy can affect the result. When in doubt, consult a numerical analyst.
( abs [ real? x ] )
Abs returns the absolute value of its argument.
( abs [ real? x ] )
The abs procedure returns the absolute value of its argument.
( and test1 ... )
The 〈test〉 expressions are evaluated from left to right, and the value of the first expression that evaluates to a false value (see section 6.3.1) is returned. Any remaining ex- pressions are not evaluated. If all the expressions evaluate to true values, the value of the last expression is returned. If there are no expressions then #t is returned.
( and test1 ... )
Semantics: The test expressions are evaluated from left to right, and if any expression evaluates to #f (see section 6.3), then #f is returned. Any remaining expressions are not evaluated. If all the expressions evaluate to true values, the values of the last expression are returned. If there are no expressions, then #t is returned.
( append [ list? list ] ... ) ( append [ list? list ] ... obj ) *
eturns a list consisting of the elements of the first list followed by the elements of the other lists. The resulting list is always newly allocated, except that it shares structure with the last list argument. The last argument may actually be any object; an improper list results if the last argument is not a proper list.
( append [ list? list ] ... ) ( append [ list? list ] ... obj ) *
Returns a list consisting of the elements of the first list followed by the elements of the other list s. If there are no arguments, the empty list is returned. If there is exactly one argument, it is returned. Otherwise the resulting list is always newly allocated, except that it shares structure with the last argument. An improper list results if the last argument is not a proper list.
( apply [ procedure? proc ] arg1 ... [ list? args ] ) *
Proc must be a procedure and args must be a list. Calls proc with the elements of the list (append (list arg1 . . . ) args) as the actual arguments.
( assoc obj [ list? alist ] ) ( or #f )
Alist (for "association list") must be a list of pairs. These procedures find the first pair in alist whose car field is obj, and returns that pair. If no pair in alist has obj as its car,then #f (not the empty list) is returned. Assoc uses equal? to compare obj with the car fields of the pairs in alist.
( assoc obj [ list? alist ] ) ( or #f ) ( assoc obj [ list? alist ] [ procedure? = ] ) ( or #f )
= ( λ a b ) *
It is an error if alist (for "association list") is not a list of pairs. This procedure finds the first pair in alist whose car field is obj, and returns that pair. If no pair in alist has obj as its car, then #f (not the empty list) is returned. The assoc procedure uses compare if given and equal? otherwise. Rationale: Although they are often used as predicates, memq, memv, member, assq, assv, and assoc do not have question marks in their names because they return potentially useful values rather than just #t or #f.
( assq obj [ list? alist ] ) ( or #f )
Alist (for "association list") must be a list of pairs. These procedures find the first pair in alist whose car field is obj, and returns that pair. If no pair in alist has obj as its car,then #f (not the empty list) is returned. Assq uses eq? to compare obj with the car fields of the pairs in alist.
( assq obj [ list? alist ] ) ( or #f )
It is an error if alist (for "association list") is not a list of pairs. This procedure finds the first pair in alist whose car field is obj, and returns that pair. If no pair in alist has obj as its car, then #f (not the empty list) is returned. The assq procedure uses eq? to compare obj with the car fields of the pairs in alist. Rationale: Although they are often used as predicates, memq, memv, member, assq, assv, and assoc do not have question marks in their names because they return potentially useful values rather than just #t or #f.
( assv obj [ list? alist ] ) ( or #f )
Alist (for "association list") must be a list of pairs. These procedures find the first pair in alist whose car field is obj, and returns that pair. If no pair in alist has obj as its car,then #f (not the empty list) is returned. Assv uses eqv? to compare obj with the car fields of the pairs in alist.
( assv obj [ list? alist ] ) ( or #f )
It is an error if alist (for "association list") is not a list of pairs. This procedure finds the first pair in alist whose car field is obj, and returns that pair. If no pair in alist has obj as its car, then #f (not the empty list) is returned. The assv procedure uses eqv? to compare obj with the car fields of the pairs in alist. Rationale: Although they are often used as predicates, memq, memv, member, assq, assv, and assoc do not have question marks in their names because they return potentially useful values rather than just #t or #f.