# Base Library The `(scheme base)` library exports many of the procedures and syntax bindings that are traditionally associated with Scheme. For more information see the [R7RS Scheme Specification](../../r7rs.pdf). - [`abs`](#abs) - [`and`](#and) - [`any`](#any) - [`append`](#append) - [`assoc`](#assoc) - [`assq`](#assq) - [`assv`](#assv) - [`begin`](#begin) - [`boolean=?`](#boolean) - [`bytevector-copy`](#bytevector-copy) - [`bytevector-copy!`](#bytevector-copy-1) - [`call-with-current-continuation`](#call-with-current-continuation) - [`call-with-port`](#call-with-port) - [`call-with-values`](#call-with-values) - [`call/cc`](#callcc) - [`case`](#case) - [`ceiling`](#ceiling) - [`char<=?`](#char) - [`char=?`](#char-3) - [`char>?`](#char-4) - [`complex?`](#complex) - [`cond`](#cond) - [`cond-expand`](#cond-expand) - [`current-error-port`](#current-error-port) - [`current-input-port`](#current-input-port) - [`current-output-port`](#current-output-port) - [`define-record-type`](#define-record-type) - [`denominator`](#denominator) - [`do`](#do) - [`dynamic-wind`](#dynamic-wind) - [`eof-object`](#eof-object) - [`error`](#error) - [`even?`](#even) - [`every`](#every) - [`exact`](#exact) - [`exact-integer?`](#exact-integer) - [`exact?`](#exact) - [`expt`](#expt) - [`features`](#features) - [`floor`](#floor) - [`floor-quotient`](#floor-quotient) - [`floor-remainder`](#floor-remainder) - [`floor-remainder`](#floor-remainder ) - [`floor/`](#floor-1) - [`flush-output-port`](#flush-output-port) - [`foldl`](#foldl) - [`foldr`](#foldr) - [`for-each`](#for-each) - [`gcd`](#gcd) - [`get-output-bytevector`](#get-output-bytevector) - [`get-output-string`](#get-output-string) - [`guard`](#guard) - [`inexact`](#inexact) - [`inexact?`](#inexact-1) - [`input-port-open?`](#input-port-open) - [`input-port?`](#input-port) - [`lcm`](#lcm) - [`let`](#let) - [`let*`](#let-1) - [`let*-values`](#let-values) - [`let-values`](#let-values-1) - [`letrec`](#letrec) - [`letrec*`](#letrec-1) - [`list`](#list) - [`list-copy`](#list-copy) - [`list-ref`](#list-ref) - [`list-set!`](#list-set) - [`list-tail`](#list-tail) - [`list?`](#list-1) - [`make-constructor`](#make-constructor) - [`make-getter`](#make-getter) - [`make-list`](#make-list) - [`make-parameter`](#make-parameter) - [`make-setter`](#make-setter) - [`make-string`](#make-string) - [`make-type-predicate`](#make-type-predicate) - [`map`](#map) - [`max`](#max) - [`member`](#member) - [`memq`](#memq) - [`memv`](#memv) - [`min`](#min) - [`modulo`](#modulo) - [`negative?`](#negative) - [`newline`](#newline) - [`not`](#not) - [`numerator`](#numerator) - [`odd?`](#odd) - [`open-input-bytevector`](#open-input-bytevector) - [`open-input-string`](#open-input-string) - [`open-output-bytevector`](#open-output-bytevector) - [`open-output-string`](#open-output-string) - [`or`](#or) - [`output-port-open?`](#output-port-open) - [`output-port?`](#output-port) - [`parameterize`](#parameterize) - [`positive?`](#positive) - [`quasiquote`](#quasiquote) - [`quotient`](#quotient) - [`raise`](#raise) - [`raise-continuable`](#raise-continuable) - [`rational?`](#rational) - [`read-line`](#read-line) - [`read-string`](#read-string) - [`receive`](#receive) - [`record?`](#record) - [`remainder`](#remainder) - [`reverse`](#reverse) - [`round`](#round) - [`slot-set!`](#slot-set) - [`square`](#square) - [`string`](#string) - [`string->list`](#string-list) - [`string->utf8`](#string-utf8) - [`string->vector`](#string-vector) - [`string-copy`](#string-copy) - [`string-copy!`](#string-copy-1) - [`string-fill!`](#string-fill) - [`string-for-each`](#string-for-each) - [`string-map`](#string-map) - [`string<=?`](#string-1) - [`string=?`](#string-4) - [`string>?`](#string-5) - [`symbol=?`](#symbol) - [`syntax-error`](#syntax-error) - [`truncate`](#truncate) - [`truncate-quotient`](#truncate-quotient) - [`truncate-remainder`](#truncate-remainder) - [`truncate/`](#truncate-1) - [`type-slot-offset`](#type-slot-offset) - [`unless`](#unless) - [`utf8->string`](#utf8-string) - [`values`](#values) - [`vector`](#vector) - [`vector->list`](#vector-list) - [`vector->string`](#vector-string) - [`vector-append`](#vector-append) - [`vector-copy`](#vector-copy) - [`vector-copy!`](#vector-copy-1) - [`vector-fill!`](#vector-fill) - [`vector-for-each`](#vector-for-each) - [`vector-map`](#vector-map) - [`when`](#when) - [`with-exception-handler`](#with-exception-handler) - [`with-handler`](#with-handler) - [`write-char`](#write-char) - [`write-string`](#write-string) - [`zero?`](#zero) # abs (abs num) # and *Syntax* (and {test1} ...) Semantics: The `{test}` expressions are evaluated from left to right, and if any expression evaluates to `#f`, 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. (and (= 2 2) (> 2 1)) => #t (and (= 2 2) (< 2 1)) => #f (and 1 2 '(f g)) => (f g) (and) => #t # any (any pred lst) # append (append list ...) # assoc (assoc obj alist) (assoc obj alist compare) # assq (assq obj alist) # assv (assv obj alist) # begin *Syntax* (begin {expression or definition} ...) This form of `begin` can appear as part of a `{body}`, or at the outermost level of a `{program}`, or at the REPL, or directly nested in a begin that is itself of this form. It causes the contained expressions and definitions to be evaluated exactly as if the enclosing begin construct were not present. Rationale: This form is commonly used in the output of macros which need to generate multiple definitions and splice them into the context in which they are expanded. (begin {expression1} {expression2} ...) This form of `begin` can be used as an ordinary expression. The `{expression}`'s are evaluated sequentially from left to right, and the values of the last `{expression}` are returned. This expression type is used to sequence side effects such as assignments or input and output. (define x 0) (and (= x 0) (begin (set! x 5) (+ x 1))) => 6 (begin (display "4 plus 1 equals ") (display (+ 4 1))) => unspecified and prints 4 plus 1 equals 5 # boolean=? (boolean=? b1 b2 ...) # bytevector-copy (bytevector-copy bytevector) (bytevector-copy bytevector start) (bytevector-copy bytevector start end) # bytevector-copy! (bytevector-copy! to at from) (bytevector-copy! to at from start) (bytevector-copy! to at from start end) # call-with-current-continuation (call-with-current-continuation proc) # call-with-port (call-with-port port proc) # call-with-values (call-with-values producer consumer) # call/cc (call/cc proc) # case *Syntax* (case {key} {clause1} {clause2} ...) Syntax: `{Key}` can be any expression. Each `{clause}` has the form (({datum1} ...) {expression1} {expression2} ...), where each `{datum}` is an external representation of some object. It is an error if any of the `{datum}`'s are the same anywhere in the expression. Alternatively, a `{clause}` can be of the form ((hdatum1} ...) => {expression}) The last `{clause}` can be an "else clause," which has one of the forms (else {expression1} {expression2} . . . ) or (else => {expression}). Semantics: A `case` expression is evaluated as follows. `{Key}` is evaluated and its result is compared against each `{datum}`. If the result of evaluating `{key}` is the same to a `{datum}`, then the expressions in the corresponding `{clause}` are evaluated in order and the results of the last expression in the `{clause}` are returned as the results of the case expression. If the result of evaluating `{key}` is different from every `{datum}`, then if there is an else clause, its expressions are evaluated and the results of the last are the results of the case expression; otherwise the result of the case expression is unspecified. If the selected `{clause}` or else clause uses the `=>` alternate form, then the `{expression}` is evaluated. It is an error if its value is not a procedure accepting one argument. This procedure is then called on the value of the `{key}` and the values returned by this procedure are returned by the case expression. (case (* 2 3) ((2 3 5 7) 'prime) ((1 4 6 8 9) 'composite)) => composite (case (car '(c d)) ((a) 'a) ((b) 'b)) => unspecified (case (car '(c d)) ((a e i o u) 'vowel) ((w y) 'semivowel) (else => (lambda (x) x))) => c # ceiling (ceiling z) # char<=? (char<=? c1 c2 c3 ...) # char=? (char>=? c1 c2 c3 ...) # char>? (char>? c1 c2 c3 ...) # complex? (complex? obj) # cond *Syntax* (cond {clause1} {clause2} ...) else => Syntax: `{Clauses}` take one of two forms, either ({test} {expression1} ...) where `{test}` is any expression, or ({test} => {expression}) The last `{clause}` can be an "else clause," which has the form (else {expression1} {expression2} ...) Semantics: A `cond` expression is evaluated by evaluating the `{test}` expressions of successive `{clause}`'s in order until one of them evaluates to a true value. When a `{test}` evaluates to a true value, the remaining `{expression}`'s in its `{clause}` are evaluated in order, and the results of the last `{expression}` in the `{clause}` are returned as the results of the entire cond expression. If the selected `{clause}` contains only the `{test}` and no `{expression}`'s, then the value of the `{test}` is returned as the result. If the selected `{clause}` uses the `=>` alternate form, then the `{expression}` is evaluated. It is an error if its value is not a procedure that accepts one argument. This procedure is then called on the value of the `{test}` and the values returned by this procedure are returned by the cond expression. If all `{test}`'s evaluate to `#f`, and there is no else clause, then the result of the conditional expression is unspecified; if there is an else clause, then its `{expression}`'s are evaluated in order, and the values of the last one are returned. (cond ((> 3 2) 'greater) ((< 3 2) 'less)) => greater (cond ((> 3 3) 'greater) ((< 3 3) 'less) (else 'equal)) => equal (cond ((assv 'b '((a 1) (b 2))) => cadr) (else #f)) => 2 # cond-expand *Syntax* (cond-expand {ce-clause2} {ce-clause2} ...) Syntax: The `cond-expand` expression type provides a way to statically expand different expressions depending on the implementation. A `{ce-clause}` takes the following form: ({feature requirement} {expression} ...) The last clause can be an "else clause," which has the form (else {expression} ...) A `{feature requirement}` takes one of the following forms: - `{feature identifier}` - `(library {library name})` - `(and {feature requirement} ...)` - `(or {feature requirement} ...)` - `(not {feature requirement})` Semantics: Each Scheme implementation maintains a list of feature identifiers which are present, as well as a list of libraries which can be imported. The value of a `{feature requirement}` is determined by replacing each `{feature identifier}` and `(library {library name})` on the implementation’s lists with `#t`, and all other feature identifiers and library names with `#f`, then evaluating the resulting expression as a Scheme boolean expression under the normal interpretation of `and`, `or`, and `not`. A `cond-expand` is then expanded by evaluating the `{feature requirement}`'s of successive `{ce-clause}`'s in order until one of them returns `#t`. When a true clause is found, the corresponding `{expression}`'s are expanded to a begin, and the remaining clauses are ignored. If none of the `{feature requirement}`'s evaluate to `#t`, then if there is an else clause, its `{expression}`'s are included. Otherwise, the behavior of the cond-expand is unspecified. Unlike cond, `cond-expand` does not depend on the value of any variables. # current-error-port (current-error-port) # current-input-port (current-input-port) # current-output-port (current-output-port) # define-record-type *Syntax* (define-record-type {name} {constructor} {pred} {field} ...) # denominator (denominator n) # do *Syntax* (do (({variable1} {init1} {step1}) ...) ({test} {expression} ...) {command} ...) # dynamic-wind (dynamic-wind before thunk after) # eof-object (eof-object) # error (error message obj ...) # even? (even? num) # every (every pred lst) # exact (exact? num) # exact-integer? (exact-integer? num) # exact? (exact? num) # expt (expt z1 z2) # features (features) # floor (floor z) # floor-quotient (floor-quotient n m) # floor-remainder (floor-remainder n m) # floor/ (floor/ n m) # flush-output-port (flush-output-port) (flush-output-port port) # foldl (foldl func accum lst) # foldr (foldr func end lst) # for-each (for-each proc list1 list2 ...) # gcd (gcd n1 ...) # get-output-bytevector (get-output-bytevector port) # get-output-string (get-output-string port) # guard *Syntax* (guard ({variable} {cond clause1} {cond clause2} ...) {body}) # inexact (inexact z) # inexact? (inexact? num) # input-port-open? (input-port-open? port) # input-port? (input-port? port) # lcm (lcm n1 ...) # let *Syntax* (let {bindings} {body}) `{bindings}` has the form: (({variable1} {init1}) ...) where each `{init}` is an expression, and `{body}` is a sequence of zero or more definitions followed by a sequence of one or more expressions. It is an error for a `{variable}` to appear more than once in the list of variables being bound. Semantics: The `{init}`'s are evaluated in the current environment (in some unspecified order), the `{variable}`'s are bound to fresh locations holding the results, the `{body}` is evaluated in the extended environment, and the values of the last expression of `{body}` are returned. Each binding of a `{variable}` has `{body}` as its region. (let ((x 2) (y 3)) (* x y)) => 6 (let ((x 2) (y 3)) (let ((x 7) (z (+ x y))) (* z x))) => 35 # let* *Syntax* (let* {bindings} {body}) `{bindings}` has the form: (({variable1} {init1}) ...) where each `{init}` is an expression, and `{body}` is a sequence of zero or more definitions followed by a sequence of one or more expressions. It is an error for a `{variable}` to appear more than once in the list of variables being bound. Semantics: The `let*` binding construct is similar to `let`, but the bindings are performed sequentially from left to right, and the region of a binding indicated by `({variable} {init})` is that part of the `let*` expression to the right of the binding. Thus the second binding is done in an environment in which the first binding is visible, and so on. The `{variable}`'s need not be distinct. (let ((x 2) (y 3)) (let* ((x 7) (z (+ x y))) (* z x))) => 70 # let*-values *Syntax* (let*-values {mv binding spec} {body}) # let-values *Syntax* (let-values {mv binding spec} {body}) # letrec *Syntax* (letrec {bindings} {body}) `{bindings}` has the form: (({variable1} {init1}) ...) where each `{init}` is an expression, and `{body}` is a sequence of zero or more definitions followed by a sequence of one or more expressions. It is an error for a `{variable}` to appear more than once in the list of variables being bound. Semantics: The `{variable}`'s are bound to fresh locations holding unspecified values, the `{init}`'s are evaluated in the resulting environment (in some unspecified order), each `{variable}` is assigned to the result of the corresponding `{init}`, the `{body}` is evaluated in the resulting environment, and the values of the last expression in `{body}` are returned. Each binding of a `{variable}` has the entire letrec expression as its region, making it possible to define mutually recursive procedures. (letrec ((even? (lambda (n) (if (zero? n) #t (odd? (- n 1))))) (odd? (lambda (n) (if (zero? n) #f (even? (- n 1)))))) (even? 88)) => #t One restriction on `letrec` is very important: if it is not possible to evaluate each `{init}` without assigning or referring to the value of any `{variable}`, it is an error. The restriction is necessary because letrec is defined in terms of a procedure call where a lambda expression binds the `{variable}`'s to the values of the `{init}`'s. In the most common uses of letrec, all the `{init}`'s are lambda expressions and the restriction is satisfied automatically. # letrec* *Syntax* (letrec* {bindings} {body}) `{bindings}` has the form: (({variable1} {init1}) ...) where each `{init}` is an expression, and `{body}` is a sequence of zero or more definitions followed by a sequence of one or more expressions. It is an error for a `{variable}` to appear more than once in the list of variables being bound. Semantics: The `{variable}`'s are bound to fresh locations, each `{variable}` is assigned in left-to-right order to the result of evaluating the corresponding `{init}`, the `{body}` is evaluated in the resulting environment, and the values of the last expression in `{body}` are returned. Despite the left-to-right evaluation and assignment order, each binding of a `{variable}` has the entire `letrec*` expression as its region, making it possible to define mutually recursive procedures. If it is not possible to evaluate each `{init}` without assigning or referring to the value of the corresponding `{variable}` or the `{variable}` of any of the bindings that follow it in `{bindings}`, it is an error. Another restriction is that it is an error to invoke the continuation of an `{init}` more than once. (letrec* ((p (lambda (x) (+ 1 (q (- x 1))))) (q (lambda (y) (if (zero? y) 0 (+ 1 (p (- y 1)))))) (x (p 5)) (y x)) y) => 5 # list (list obj ...) # list-copy (list-copy lst) # list-ref (list-ref lst k) # list-set! (list-set! lst k obj) # list-tail (list-tail lst k) # list? (list? o) # make-constructor (make-constructor make name) # make-getter (make-getter sym name idx) # make-list (make-list k ) (make-list k fill) # make-parameter (make-parameter init) (make-parameter init converter) # make-setter (make-setter sym name idx) # make-string (make-string k) (make-string k fill) # make-type-predicate (make-type-predicate pred name) # map (map proc list1 list2 ...) # max (max x1 x2 ...) # member (member obj lst) (member obj lst compare) # memq (memq obj lst) # memv (memv obj lst) # min (min x1 x2 ...) # modulo (modulo a b) # negative? (negative? n) # newline (newline) (newline port) # not (not x) # numerator (numerator n) n) # odd? (odd? num) # open-input-bytevector (open-input-bytevector bv) # open-input-string (open-input-string string) # open-output-bytevector (open-output-bytevector open-output-string) # open-output-string (open-output-string) # or *Syntax* (or {test1} ...) Semantics: The `{test}` expressions are evaluated from left to right, and the value of the first expression that evaluates to a true value is returned. Any remaining expressions are not evaluated. If all expressions evaluate to `#f` or if there are no expressions, then `#f` is returned. (or (= 2 2) (> 2 1)) => #t (or (= 2 2) (< 2 1)) => #t (or #f #f #f) => #f (or (memq 'b '(a b c)) (/ 3 0)) => (b c) # output-port-open? (output-port-open? port) # output-port? (output-port? obj) # parameterize *Syntax* (parameterize (({param1} {value1}) ...) {body}) # positive? (positive? n) # quasiquote *Syntax* (quasiquote {qq template}) # quotient (quotient x y) # raise (raise obj) # raise-continuable (raise-continuable obj) # rational? (rational? obj) # read-line (read-line) (read-line port) # read-string (read-string k) (read-string k port) # receive *Syntax* (receive {formals} {expression} {body}) # record? (record? obj) # remainder (remainder num1 num2) # reverse (reverse lst) # round (round z) # slot-set! (slot-set! name obj idx val) # square (square z) # string (string char ...) # string->list (string->list string) (string->list string start) (string->list string start end) # string->utf8 (string->utf8 string) (string->utf8 string start) (string->utf8 string start end) # string->vector (string->vector string) (string->vector string start) (string->vector string start end) # string-copy (string-copy string) (string-copy string start) (string-copy string end) # string-copy! (string-copy! to at from) (string-copy! to at from start) (string-copy! to at from start end) # string-fill! (string-fill! str fill) (string-fill! str fill start) (string-fill! str fill start end) # string-for-each (string-for-each proc string1 string2 ...) # string-map (string-map proc string1 string2 ...) # string<=? (string<=? str1 str2) # string=? (string>=? str1 str2) # string>? (string>? str1 str2) # symbol=? (symbol=? symbol1 symbol2 symbol3 ...) # syntax-error *Syntax* (syntax-error {message} {args} ...) # truncate (truncate z) # truncate-quotient (truncate-quotient quotient) # truncate-remainder (truncate-remainder remainder) # truncate/ (truncate/ n m) # type-slot-offset (type-slot-offset name sym) # unless *Syntax* (unless {test} {expression1} {expression2} ...) Syntax: The `{test}` is an expression. Semantics: The `test` is evaluated, and if it evaluates to `#f`, the expressions are evaluated in order. The result of the when expression is unspecified. (unless (= 1 1.0) (display "1") (display "2")) => unspecified and prints nothing # utf8->string (utf8->string bytevector) (utf8->string bytevector start) (utf8->string bytevector start end) # values (values obj ...) # vector (vector obj ...) # vector->list (vector->list vector) (vector->list vector start) (vector->list vector start end) # vector->string (vector->string vector) (vector->string vector start) (vector->string vector start end) # vector-append (vector-append vector ...) # vector-copy (vector-copy vector) (vector-copy vector start) (vector-copy vector start end) # vector-copy! (vector-copy! to at from) (vector-copy! to at from start) (vector-copy! to at from start end) # vector-fill! (vector-fill! vector fill) (vector-fill! vector fill start) (vector-fill! vector fill start end) # vector-for-each (vector-for-each proc vector1 vector2 ...) # vector-map (vector-map proc vector1 vector2 ...) # when *Syntax* (when {test} {expression1} {expression2} ...) Syntax: The `{test}` is an expression. Semantics: The `test` is evaluated, and if it evaluates to a true value, the expressions are evaluated in order. The result of the when expression is unspecified. (when (= 1 1.0) (display "1") (display "2")) => unspecified and prints 12 # with-exception-handler (with-exception-handler handler thunk) # with-handler (with-handler handler body) # write-char (write-char char) (write-char char port) # write-string (write-string string) (write-string string port) # zero? (zero? n)