Library file extensions

The file extension also controls the reader mode.

.ss and .sls

When a file with one of the extensions is loaded during library importing, then #!r6rs directive is applied to the target file by default.

.sld

When a file has this extensions, then #!r7rs directive is applied to the target file by default.

.scm

This file extension uses #!compatible directive.

If the loading file contains other directive, then the default directive is overwritten.

If you want to write portable code yet want to use Sagittarius specific functionality, then you can write implementation specific code separately using .sagittarius.scm, .sagittarius.ss, .sagittarius.sls or .sagittarius.sld extensions. This functionality is implemented almost all R6RS implementation. If you use R7RS style library syntax, then you can also use cond-expand to separate implementation specific functionalities.

Hidden library

If you don't want to share a library but only used in specific one, you can write both in one file and name the file you want to show. For example;

(library (not showing)
  ;; exports all internal use procedures
  (export ...)
  (import (rnrs))
;; write procedures
...
)

(library (shared)
  (export shared-procedure ...)
  (import (rnrs) (not showing))
;; write shared procedures here
)

Above script must be saved the file named shared.scm. The order of libraries are important. Top most dependency must be the first and next is second most, so on.

Note: This style can hide some private procedures however if you want to write portable code, some implementations do not allow you to write this style.

Macro expansion

The following code will print #t instead of #f with -r6command line option or doing it on a library:

(import (rnrs) (for (rnrs eval) expand))

(define-syntax foo
  (lambda(ctx)
    (syntax-case ctx ()
      ((_ id)
       (free-identifier=?
	#'id
	(eval '(datum->syntax #'k 'bar) (environment '(rnrs))))))))

(define bar)

(display (foo bar))

This is because, Sagittarius doesn't have separated phases of macro expansion and compilation. When foo is expanded, then the bar is not defined yet or at least it's not visible during the macro expansion. So, both _bar_s are not bound, then free-identifier=? will consider them the same identifiers.

Directives

On R6RS, symbol starts with #! is ignored, however this is not the case on R7RS. Sagittarius ignores these symbols on both mode.

Variable definitions

[R6RS] The define form is a definition used to create variable bindings and may appear anywhere other definitions may appear.

The first from of define binds variable to a new location before assigning the value of expression to it.

(define add3 (lambda (x) (+ x 3)))

(add3 3)

(define first car)

(first '(1 2))

The second form of define is equivalent to

(define _variable_ _unspecified_)

where unspecified is a side-effect-free expression returning an unspecified value.

In the third form of define, formals must be either a sequence of zero or more variables, or a sequence of one or more variables followed by a dot . and another variable. This form is equivalent to

(define _variable_ (lambda (_formals_) _body ..._))

In the fourth form of define, formal must be a single variable. This form is equivalent to

(define _variable_ (lambda _formal_ _body ..._))

Syntax definitions

[R6RS] The define-syntax form is a definition used to create keyword bindings and may appear anywhere other definitions may appear.

Binds keyword to the value of expression, which must evaluate, at macro-expansion time, to a transformer.

Quotation

[R6RS] quote evaluates to the datum value represented by datum.

(quote a)

(quote #(a b c))

(quote (+ 1 2))

Procedures

[R6RS+]A lambda expression evaluates to a procedure. The environment in effect when the lambda expression is evaluated is remembered as part of the procedure. When the procedure is later called with some arguments, the environment in which the lambda expression was evaluated is extended by binding the variables in the parameter list to fresh locations, and the resulting argument values are stored in those locations. Then, the expressions in the body of the lambda expression are evaluated sequentially in the extended environment. The results of the last expression in the body are returned as the results of the procedure call.

(lambda (x) (+ x x))

((lambda (x) (+ x x)) 4)

((lambda (x)
   (define (p y) (+ y 1))
   (+ (p x) x)) 5)

(define reverse-subtract (lambda (x y) (- y x)))

(reverse-subtract 7 10)

(define add4 (let ((x 4)) (lambda (y) (+ x y))))

(add4 6)

Formals must have one of the following forms:

• (<variable1> ...) The procedure takes a fixed number of arguments; when the procedure is called, the arguments are stored in the bindings of the corresponding variables.

• <variable> The procedure takes any number of arguments; when the procedure is called, the sequence of arguments is converted into a newly allocated list, and the list is stored in the binding of the <variable>.

• (<variable1> ... <variablen> . <variablen+1>) If a period . precedes the last variable, then the procedure takes n or more arguments, where n is the number of parameters before the period (there must be at least one). The value stored in the binding of the last variable is a newly allocated list of the arguments left over after all the other arguments have been matched up against the other parameters.

  ((lambda x x) 3 4 5 6)

  (3 4 5 6)

  ((lambda (x y . z) z)  3 4 5 6)

  (5 6)
  Any variable must not appear more than once in formals.

• (<variable> ... <extended-spec> ...)

  Extended argument specification. Zero or more variables that specifies required formal argument, followed by an <extended-spec>, a list begginning with a keyword :optional, :key or :rest. The <extended-spec> part consists of the optional argument spec, the keyword argument spec and the rest argument spec. They can appear in any combinations.

  :optional _optspec_ ...

  ecifies optional arguments. Each optspec can be either one of the following forms:

  _variable_

  (_variable_ _init-expr_)

  The variable names the formal argument, which is bound to the value of the actual argument if given, or the value of the expression init-expr otherwise. If optspec is just a variable, and the actual argument is not given, then it will be unspecified value. The expression init-expr is only evaluated if the actual argument is not given. The scope in which init-expr is evaluated includes the preceding formal arguments.

  ((lambda (a b :optional (c (+ a b))) (list a b c)) 1 2) 

  (1 2 3)

  ((lambda (a b :optional (c (+ a b))) (list a b c)) 1 2 -1) 

  (1 2 -1)

  ((lambda (a b :optional c) (list a b c)) 1 2) 

  (1 2 #\<unspecified>)

  ((lambda (:optional (a 0) (b (+ a 1))) (list a b))) 

  (1 2)

  The procedure raises an &serious if more actual arguments than the number of required and optional arguments are given, unless it also has :key or :rest arguments spec.

  ((lambda (:optional a b) (list a b)) 1 2 3) 

  &serious

  ((lambda (:optional a b :rest r) (list a b r)) 1 2 3) 

  (1 2 (3))

  :key _keyspec_ ... [:allow-other-keys [_variable_]]

  ecifies keyword arguments. Each keyspec can be one of the following forms.

  _variable_

  (_variable_ _init-expr_)

  ((_keyword_ _variable_) _init-expr_)

  (_variable_ _keyword_ _init-expr_)

  The variable names the formal argument, which is bound to the actual argument given with the keyword of the same name as variable. When the actual is not given, init-expr is evaluated and the result is bound to variable in the second, third and fourth form, or unspecified value is bound in the first form.

  (define f (lambda (a :key (b (+ a 1)) (c (+ b 1)))
        (list a b c)))
  

  (f 10)

  (10 11 12)

  (f 10 :b 4)

  (10 4 5)

  (f 10 :c 8)

  (10 11 8)

  (f 10 :c 1 :b 3)

  (10 3 1)

  With the third and fourth form you can name the formal argument differently from the keyword to specify the argument.

  ((lambda (:key ((:aa a) -1)) a) ::aa 2)

  2

  ((lambda (:key (a :aa -1)) a) ::aa 2)

  2

  By default, the procedure with keyword argument spec raises &serious if a keyword argument with an unrecognized keyword is given. Giving :allow-other-keys in the formals suppresses this behaviour. If you give variable after :allow-other-keys, the list of unrecognized keywords and their arguments are bound to it.

  ((lambda (:key a) a) :a 1 :b 2)

  &serious

  ((lambda (:key a :allow-other-keys) a) :a 1 :b 2)

  1

  ((lambda (:key a :allow-other-keys z) (list a z)) :a 1 :b 2) 

  (1 (b 2))

  When used with :optional argument spec, the keyword arguments are searched after all the optional arguments are bound.

  ((lambda (:optional a b :key c) (list a b c)) 1 2 :c 3) 

  (1 2 3)

  ((lambda (:optional a b :key c) (list a b c)) :c 3) 

  (c 3 #\<unspecified>)

  ((lambda (:optional a b :key c) (list a b c)) 1 :c 3) 

  &serious

  :rest _variable_

  ecifies the rest argument. If specified without :optional argument spec, a list of remaining arguments after required arguments are taken is bound to variable. If specified with :optional argument spec, the actual arguments are first bound to required and all optional arguments, and the remaining arguments are bound to variable.

  ((lambda (a b :rest z) (list a b z)) 1 2 3 4 5) 

  (1 2 (3 4 5))

  ((lambda (a b :optional c d :rest z) (list a b z)) 1 2 3 4 5) 

  (1 2 3 4 (5))

       ((lambda (a b :optional c d :rest z) (list a b z)) 1 2 3)

  (1 2 3 #\<unspecified> ())

  When the rest argument spec is used with the keyword argument spec, both accesses the same list of actual argument -- the remaining arguments after required and optional arguments are taken

  ((lambda (:optional a :rest r :key k) (list a r k)) 1 :k 3) 

  (1 (k 3) 3)

Conditionals

[R6RS]An if expression is evaluated as follows: first, _test_is evaluated. If it yields a true value, then consequent is evaluated and its values are returned. Otherwise alternate is evaluated and its values are returned. If test yields #f and no alternate is specified, then the result of the expression is unspecified.

Assignment

[R6RS] Expression is evaluated, and the resulting value is stored in the location to which variable is bound. Variable must be bound either in some region enclosing the set! expression or at the top level. The result of the set! expression is unspecified.

Note: R6RS requires to throw syntax violation if variable refers immutable binding. In Sagittarius, however, it won't throw any error.

Derived conditionals

[R6RS] Each clause must be the form

(_test_ _expression_ ...)

(_test_ => _expression_)

(else _expression_ ...)

The last form can appear only in the last clause.

A cond expression is evaluated by evaluating the test expressions of successive clauses in order until one of them evaluates to a true value. When a test evaluates to a true value, then the remaining expressions 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 expressions, then the value of the test is returned as the result. If the selected clause uses the => alternate form, then the expression is evaluated. Its value must be a procedure. This procedure should accept one argument; it is called on the value of the test and the values returned by this procedure are returned by the cond expression. If all tests evaluate to #f, and there is no else clause, then the conditional expression returns unspecified values; if there is an else clause, then its expressions are evaluated, and the values of the last one are returned.

[R6RS] Key must be an expression. Each clause must have one of the following forms:

((_datum_ ...) _expression_ ...)

(else _expression_ ...)

The last form can appear only in the last clause.

A case expression is evaluated as follows. Key is evaluated and its result is compared using eqv? against the data represented by the _datums_of each clause in turn, proceeding in order from left to right through the set of clauses. If the result of evaluating key is equivalent to a datum of a clause, the corresponding expressions are evaluated from left to right and the results of the last expression in the clause are returned as the results of the case expression. Otherwise, the comparison process continues. If the result of evaluating key is different from every datum in each set, 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 case expression returns unspecified values.

[R6RS] If there are no tests, #t is returned. Otherwise, the test expressions are evaluated from left to right until a _test_returns #f or the last test is reached. In the former case, the and expression returns #f without evaluating the remaining expressions. In the latter case, the last expression is evaluated and its values are returned.

(and (= 2 2) (> 2 1))

(and (= 2 2) (< 2 1))

(and 1 2 'c '(f g))

(and)

[R6RS] If there are no tests, #f is returned. Otherwise, the _test_expressions are evaluated from left to right until a test returns a true value or the last test is reached. In the former case, the or expression returns val without evaluating the remaining expressions. In the latter case, the last expression is evaluated and its values are returned.

(or (= 2 2) (> 2 1))

(or (= 2 2) (< 2 1))

(or #f #f #f)

(or '(b c) (/ 3 0))

Binding constructs

[R6RS] Bindings must have the form

((_variable1_ _init1_) ...)

where each init is an expression. Any variable must not appear more than once in the variables.

The inits are evaluated in the current environment, the variables 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.

[R6RS] Bindings must have the form

((_variable1_ _init1_) ...)

The let* form is similar to let, but the inits are evaluated and bindings created sequentially from left to right, with the region of each binding including the bindings to its right as well as body. Thus the second init is evaluated in an environment in which the first binding is visible and initialized, and so on.

[R6RS] Bindings must have the form

((_variable1_ _init1_) ...)

where each init is an expression. Any variable must not appear more than once in the variables.

The variables are bound to fresh locations, the inits are evaluated in the resulting environment, 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.

In the most common uses of letrec, all the inits are lambdaexpressions and the restriction is satisfied automatically.

[R6RS] Bindings must have the form

((_variable1_ _init1_) ...)

where each init is an expression. Any variable must not appear more than once in the variables.

The variables 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.

[R6RS] Mv-bindings must have the form

((_formals_ _init1_) ...)

where each init is an expression. Any variable must not appear more than once in the set of formals.

The inits are evaluated in the current environment, and the variables occurring in the formals are bound to fresh locations containing the values returned by the inits, where the formals are matched to the return values in the same way that the formals in a lambda expression are matched to the arguments in a procedure call. Then, 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. If the formals do not match, an exception with condition type &assertionis raised.

[R6RS] Mv-bindings must have the form

((_formals_ _init1_) ...)

where each init is an expression. In each formals, any variable must not appear more than once.

The let*-values form is similar to let-values, but the _inits_are evaluated and bindings created sequentially from left to right, with the region of the bindings of each formals including the bindings to its right as well as body. Thus the second init is evaluated in an environment in which the bindings of the first formals is visible and initialized, and so on.

Sequencing

[R6RS]The begin keyword has two different roles, depending on its context:

• It may appear as a form in a body , library body, or top-level body, or directly nested in a begin form that appears in a body. In this case, the begin form must have the shape specified in the first header line. This use of begin acts as a splicing form - the forms inside the body are spliced into the surrounding body, as if the begin wrapper were not actually present. A begin form in a body or library body must be non-empty if it appears after the first expression within the body.

• It may appear as an ordinary expression and must have the shape specified in the second header line. In this case, the expressions 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.

Equivalence predicates

A predicate is a procedure that always returns a boolean value (#t or #f). An equivalence predicate is the computational analogue of a mathematical equivalence relation (it is symmetric, reflexive, and transitive). Of the equivalence predicates described in this section, eq? is the finest or most discriminating, and equal? is the coarsest. The eqv? predicate is slightly less discriminating than eq?.

[R6RS] eq? only sees if the given two objects are the same object or not, eqv? compares numbers. equal? compares the values equivalence.

On Sagittarius Scheme interned symbol, keyword(only compatible mode), character, literal string, boolean, fixnum, and '() are used as the same objects. If these objects indicates the same value then eq? returns #t.

The following examples are not specified R6RS. But it is always good to know how it works.

(let ((p (lambda (x) x))) (eqv? p p))

(eqv? "" "")

(eqv? "abc" "abc") ;; literal string are the same object

(eqv? "abc" (list->string '(#\a #\b #\c)))

(eqv? '#() '#())

(eqv? (lambda (x) x) (lambda (x) x))

(eqv? (lambda (x) x) (lambda (y) y))

(eqv? +nan.0 +nan.0)

Procedure predicate

[R6RS] Returns #t if obj is a procedure, otherwise returns #f.

Numerical type predicates

[R6RS] These numerical type predicates can be applied to any kind of argument. They return #t if the object is a number object of the named type, and #f otherwise. In general, if a type predicate is true of a number object then all higher type predicates are also true of that number object. Consequently, if a type predicate is false of a number object, then all lower type predicates are also false of that number object.

If z is a complex number object, then (real? _z_) is true if and only if (zero? (imag-part _z_)) and (exact? (imag-part _z_))are both true.

If x is a real number object, then (rational? _x_) is true if and only if there exist exact integer objects k1 and k2 such that (= _x_ (/ _k1_ _k2_)) and (= (numerator _x_) _k1_)and (= (denominator _x_) _k2_) are all true. Thus infinities and NaNs are not rational number objects.

If q is a rational number objects, then (integer? _q_) is true if and only if (= (denominator _q_) 1) is true. If q is not a rational number object, then (integer? _q_) is #f.

[R6RS] These numerical type predicates can be applied to any kind of argument. The real-valued? procedure returns #t if the object is a number object and is equal in the sense of = to some real number object, or if the object is a NaN, or a complex number object whose real part is a NaN and whose imaginary part is zero in the sense of zero?. The rational-valued? and integer-valued?procedures return #t if the object is a number object and is equal in the sense of = to some object of the named type, and otherwise they return #f.

[R6RS] These numerical predicates provide tests for the exactness of a quantity. For any number object, precisely one of these predicates is true.

Generic conversion

[R6RS] The inexact procedure returns an inexact representation of z. If inexact number objects of the appropriate type have bounded precision, then the value returned is an inexact number object that is nearest to the argument.

The exact procedure returns an exact representation of z. The value returned is the exact number object that is numerically closest to the argument; in most cases, the result of this procedure should be numerically equal to its argument.

Arithmetic operations

[R6RS] These procedures return #t if their arguments are (respectively): equal, monotonically increasing, monotonically decreasing, monotonically nondecreasing, or monotonically nonincreasing, and #f otherwise.

[R6RS] These numerical predicates test a number object for a particular property, returning #t or #f.

The zero? procedure tests if the number object is = to zero.

The positive? tests whether it is greater than zero.

The negative? tests whether it is less than zero.

The odd? tests whether it is odd.

The even? tests whether it is even

The finite? tests whether it is not an infinity and not a NaN.

The infinite? tests whether it is an infinity.

The nan? tests whether it is a NaN.

[R6RS] These procedures return the maximum or minimum of their arguments.

[R6RS] These procedures return the sum or product of their arguments.

[R6RS] With two or more arguments, this procedures returns the difference of its arguments, associating to the left. With one argument, however, it returns the additive inverse of its argument.

If this procedure is applied to mixed non-rational real and non-real complex arguments, it returns an unspecified number object.

[R6RS+] If all of the arguments are exact, then the divisors must all be nonzero. 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.

If this procedure is applied to mixed non-rational real and non-real complex arguments, it returns an unspecified number object.

In R6RS, it requires to raise &assertion when the divisor was 0, on Sagittarius, however, it returns NaN or infinite number when it is running with compatible mode. In R6RS mode it raises &assertion.

[R6RS] Returns the absolute value of its argument.

[R6RS] These procedures implement number-theoretic integer division and return the results of the corresponding mathematical operations. In each case, x1 must be neither infinite nor a NaN, and x2 must be nonzero; otherwise, an exception with condition type &assertion is raised.

[R6RS] These procedures return the greatest common divisor or least common multiple of their arguments. The result is always non-negative.

[R6RS] These procedures return the numerator or denominator of their argument; the result is computed as if the argument was represented as a fraction in lowest terms. The denominator is always positive. The denominator of 0 is defined to be 1.

[R6RS] These procedures return inexact integer objects for inexact arguments that are not infinities or NaNs, and exact integer objects for exact rational arguments. For such arguments, floor returns the largest integer object not larger than x. The ceiling procedure returns the smallest integer object not smaller than x. The truncate procedure returns the integer object closest to x whose absolute value is not larger than the absolute value of x. The round procedure returns the closest integer object to x, rounding to even when x represents a number halfway between two integers.

Although infinities and NaNs are not integer objects, these procedures return an infinity when given an infinity as an argument, and a NaN when given a NaN.

[R6RS] The rationalize procedure returns the a number object representing the simplest rational number differing from x1 by no more than x2. A rational number r1 is simpler than another rational number r2 if r1 = p1/q1 and r2 = p2/q2 (in lowest terms) and |p1| ≤ |p2| and |q1| ≤ |q2|. Thus 3/5 is simpler than 4/7. Although not all rationals are comparable in this ordering (consider 2/7 and 3/5) any interval contains a rational number that is simpler than every other rational number in that interval (the simpler 2/5 lies between 2/7 and 3/5). Note that 0 = 0/1 is the simplest rational of all.

[R6RS] These procedures compute the usual transcendental functions. The exp procedure computes the base-e exponential of z.

The log procedure with a single argument computes the natural logarithm of z (not the base-ten logarithm); (log _z1_ _z2_) computes the base-z2 logarithm of z1.

The asin, acos, and atan procedures compute arcsine, arccosine, and arctangent, respectively.

The two-argument variant of atan computes (angle (make-rectangular _x2_ _x1_)).

[R6RS] Returns the principal square root of z. For rational z, the result has either positive real part, or zero real part and non-negative imaginary part.

The sqrt procedure may return an inexact result even when given an exact argument.

[R6RS] Returns z1 raised to the power z2. For nonzero z1, this is e^{z2 log z1}. 0.0z is 1.0 if z = 0.0, and 0.0 if (real-part _z_) is positive. For other cases in which the first argument is zero, an unspecified number object(+nan.0+nan.0i) is returned.

For an exact real number object z1 and an exact integer object z2, (expt _z1_ _z2_) must return an exact result. For all other values of z1 and z2, (expt _z1_ _z2_) may return an inexact result, even when both z1 and z2 are exact.

[R6RS] Suppose a1, a2, a3, and a4 are real numbers, and c is a complex number such that the following holds:

_c = a1 + a2 ^ i = a3 e ^ ia4_Then, if x1, x2, x3, and x4 are number objects representing a1, a2, a3, and a4, respectively, (make-rectangular _x1_ _x2_) returns c, and (make-polar _x3_ _x4_) returns c.

Numerical input and output

[R6RS+] Radix must be an exact integer object, between 2, and 32. If omitted, radix defaults to 10. In Sagittarius precision will be ignored. The number->string procedure takes a number object and a radix and returns as a string an external representation of the given number object in the given radix such that

(let ((number _z_) (radix _radix_))
  (eqv? (string->number
          (number->string number radix)
          radix)
        number))

is true.

[R6RS+] Returns a number object with maximally precise representation expressed by the given string. Radix must be an exact integer object, between 2, and 32. If supplied, radix is a default radix that may be overridden by an explicit radix prefix in string (e.g., "#o177"). If radix is not supplied, then the default radix is 10. If string is not a syntactically valid notation for a number object or a notation for a rational number object with a zero denominator, then string->numberreturns #f.

These number->string and string->number's resolutions of radix are taken from Gauche.

Booleans

[R6RS] Returns #t if obj is #f, and returns #f otherwise.

[R6RS] Returns #t if obj is either #t or #f and returns #f otherwise.

[R6RS] Returns #t if the booleans are the same.

Pairs and lists

A pair is a compound structure with two fields called the car and cdr fields (for historical reasons). Pairs are created by the procedure cons. The car and cdr fields are accessed by the procedures car and cdr.

Pairs are used primarily to represent lists. A list can be defined recursively as either the empty list or a pair whose cdr is a list. More precisely, the set of lists is defined as the smallest set X such that

• The empty list is in

• If list is in X, then any pair whose cdr field contains _list_is also in X.

The objects in the car fields of successive pairs of a list are the elements of the list. For example, a two-element list is a pair whose car is the first element and whose cdr is a pair whose car is the second element and whose cdr is the empty list. The length of a list is the number of elements, which is the same as the number of pairs.

The empty listis a special object of its own type. It is not a pair. It has no elements and its length is zero.

A chain of pairs not ending in the empty list is called an improper list. Note that an improper list is not a list. The list and dotted notations can be combined to represent improper lists:

(a b c . d)

is equivalent to

(a . (b . (c . d)))

Whether a given pair is a list depends upon what is stored in the cdr field.

[R6RS] Returns #t if obj is a pair, and otherwise returns #f.

[R6RS] Returns a newly allocated pair whose car is obj1 and whose cdr is obj2. The pair is guaranteed to be different (in the sense of eqv?) from every existing object.

[R6RS] Returns the contents of the car/cdr field of pair.

:

[R6RS] These procedures are compositions of car and cdr, where for example caddr could be defined by

(define caddr (lambda (x) (car (cdr (cdr x)))))

.

Arbitrary compositions, up to four deep, are provided. There are twenty-eight of these procedures in all.

[R6RS] Returns #t if obj is the empty list, #f otherwise.

[R6RS] Returns #t if obj is a list, #f otherwise. By definition, all lists are chains of pairs that have finite length and are terminated by the empty list.

[R6RS] Returns a newly allocated list of its arguments.

[R6RS+] Returns the length of list. If the list is improper list, it returns -1 If the list is infinite list , it returns -2.

[R6RS] Returns a possibly improper list consisting of the elements of the first list followed by the elements of the other lists, with _obj_as the cdr of the final pair. An improper list results if obj is not a list.

[R6RS] Returns a newly allocated list consisting of the elements of list in reverse order.

[R6RS+] The list-tail procedure returns the subchain of pairs of list obtained by omitting the first k elements. If _fallback_is given and k is out of range, it returns fallback otherwise &assertion is raised.

[R6RS+] The list-ref procedure returns the _k_th element of list. If fallback is given and k is out of range, it returns fallback otherwise &assertion is raised.

[R6RS+ SRFI-1] The map procedure applies proc element-wise to the elements of the lists and returns a list of the results, in order. The order in which proc is applied to the elements of the lists is unspecified. If multiple returns occur from map, the values returned by earlier returns are not mutated. If the given lists are not the same length, when the shortest list is processed the map will stop.

[R6RS+ SRFI-1] The for-each procedure applies proc element-wise to the elements of the lists for its side effects, in order from the first elements to the last. The return values of for-each are unspecified. If the given lists are not the same length, when the shortest list is processed the for-each will stop.

Symbols

[R6RS] Returns #t if obj is a symbol, otherwise returns #f.

[R6RS] Returns the name of symbol as an immutable string.

[R6RS] Returns #t if the symbols are the same, i.e., if their names are spelled the same.

[R6RS] Returns the symbol whose name is string.

Characters

Characters are objects that represent Unicode scalar values.

[R6RS] Returns #t if obj is a character, otherwise returns #f.

[R6RS] Sv must be a Unicode scalar value, i.e., a non-negative exact integer object in [0, #xD7FF] ∪ [#xE000, #x10FFFF].

Given a character, char->integer returns its Unicode scalar value as an exact integer object. For a Unicode scalar value sv, integer->charreturns its associated character.

[R6RS] These procedures impose a total ordering on the set of characters according to their Unicode scalar values.

Strings

Strings are sequences of characters. The length of a string is the number of characters that it contains. This number is fixed when the string is created. The valid indices of a string are the integers less than the length of the string. The first character of a string has index 0, the second has index 1, and so on.

[R6RS] Returns #t if obj is a string, otherwise returns #f.

[R6RS] Returns a newly allocated string of length k. If _char_is given, then all elements of the string are initialized to char, otherwise the contents of the string are #\space.

These are equivalence:

(make-string 10)

[R6RS] Returns a newly allocated string composed of the arguments.

[R6RS] Returns the number of characters in the given string as an exact integer object.

[R6RS+] The string-ref procedure returns character. If a third argument is given ant k is not a valid index, it returns fallback, otherwise raises &assertion.

k of string using zero-origin indexing.

[R6RS] Returns #t if the strings are the same length and contain the same characters in the same positions. Otherwise, the string=? procedure returns #f.

[R6RS] These procedures are the lexicographic extensions to strings of the corresponding orderings on characters. For example, string<? is the lexicographic ordering on strings induced by the ordering char<? on characters. If two strings differ in length but are the same up to the length of the shorter string, the shorter string is considered to be lexicographically less than the longer string.

[R6RS] String must be a string, and start and end must be exact integer objects satisfying

0 ≤ start ≤ end ≤ (string-length _string_).

The substring procedure returns a newly allocated string formed from the characters of string beginning with index start (inclusive) and ending with index end (exclusive).

[R6RS] Returns a newly allocated string whose characters form the concatenation of the given strings.

[R6RS+] List must be a list of characters.

The string->list procedure returns a newly allocated list of the characters that make up the given string.

The list->string procedure returns a newly allocated string formed from the characters in list.

The string->list and list->string procedures are inverses so far as equal? is concerned.

If optional argument start and end are given, it restrict the conversion range. It convert from start (inclusive) to end(exclusive).

If only start is given, then the end is the length of given string.

[R6RS+] Proc should accept as many arguments as there are strings. The string-for-each procedure applies proc element-wise to the characters of the strings for its side effects, in order from the first characters to the last. The return values of string-for-each are unspecified.

Analogous to for-each.

[R6RS+] Returns a newly allocated copy of the given string.

If optional argument start was given, the procedure copies from the given start index.

If optional argument end was given, the procedure copies to the given end index (exclusive).

Vectors

Vectors are heterogeneous structures whose elements are indexed by integers. A vector typically occupies less space than a list of the same length, and the average time needed to access a randomly chosen element is typically less for the vector than for the list.

The length of a vector is the number of elements that it contains. This number is a non-negative integer that is fixed when the vector is created. The valid indices of a vector are the exact non-negative integer objects less than the length of the vector. The first element in a vector is indexed by zero, and the last element is indexed by one less than the length of the vector.

[R6RS] Returns #t if obj is a vector. Otherwise returns #f.

[R6RS] Returns a newly allocated vector of k elements. If a second argument is given, then each element is initialized to fill. Otherwise the initial contents of each element is unspecified.

[R6RS] Returns a newly allocated vector whose elements contain the given arguments. Analogous to list.

[R6RS] Returns the number of elements in vector as an exact integer object.

[R6RS+] The vector-ref procedure returns the contents of element k of vector. If a third argument is given and k is not a valid index, it returns fallback, otherwise raises &assertion.

[R6RS] K must be a valid index of vector. The vector-set!procedure stores obj in element k of vector, and returns unspecified values.

It raises &assertion when it attempt to modify immutable vector on R6RS mode.

[R6RS+] The vector->list procedure returns a newly allocated list of the objects contained in the elements of vector. The list->vectorprocedure returns a newly created vector initialized to the elements of the list list. The optional start and end arguments limit the range of the source.

(vector->list '#(1 2 3 4 5))

(list->vector '(1 2 3 4 5))

(vector->list '#(1 2 3 4 5) 2 4)

(list->vector (circular-list 'a 'b 'c) 1 6)

[R6RS+] Stores fill in every element of vector and returns unspecified values. Optional start and end limits the range of effect between start-th index (inclusive) to end-th index (exclusive). Start defaults to zero, and end defaults to the length of vector.

[R6RS+] Proc should accept as many arguments as there are vectors. The vector-map procedure applies proc element-wise to the elements of the vectors and returns a vector of the results, in order. If multiple returns occur from vector-map, the return values returned by earlier returns are not mutated.

Analogous to map.

[R6RS+] Proc should accept as many arguments as there are vectors. The vector-for-each procedure applies proc element-wise to the elements of the vectors for its side effects, in order from the first elements to the last. The return values of vector-for-each are unspecified.

Analogous to for-each.

Errors and violations

[R6RS] Who must be a string or a symbol or #f. Message must be a string. The irritants are arbitrary objects.

These procedures raise an exception. The error procedure should be called when an error has occurred, typically caused by something that has gone wrong in the interaction of the program with the external world or the user. The assertion-violation procedure should be called when an invalid call to a procedure was made, either passing an invalid number of arguments, or passing an argument that it is not specified to handle.

The who argument should describe the procedure or operation that detected the exception. The message argument should describe the exceptional situation. The irritants should be the arguments to the operation that detected the operation.

Control features

[R6RS] Rest-args must be a list. Proc should accept n arguments, where n is number of args plus the length of rest-args. The applyprocedure calls proc with the elements of the list (append (list _arg1_ ...) _rest-args_) as the actual arguments.

If a call to apply occurs in a tail context, the call to proc is also in a tail context.

[R6RS] Proc should accept one argument. The procedure call-with-current-continuation (which is the same as the procedure call/cc) packages the current continuation as an "escape procedure" and passes it as an argument to proc. The escape procedure is a Scheme procedure that, if it is later called, will abandon whatever continuation is in effect a that later time and will instead reinstate the continuation that was in effect when the escape procedure was created. Calling the escape procedure may cause the invocation of before and after procedures installed using dynamic-wind.

The escape procedure accepts the same number of arguments as the continuation of the original call to call-with-current-continuation.

[R6RS] Returns objs as multiple values.

[R6RS] Producer must be a procedure and should accept zero arguments. Consumer must be a procedure and should accept as many values as producer returns. The call-with-values procedure calls _producer_with no arguments and a continuation that, when passed some values, calls the consumer procedure with those values as arguments. The continuation for the call to consumer is the continuation of the call to call-with-values.

If a call to call-with-values occurs in a tail context, the call to consumer is also in a tail context.

[R6RS] Before, thunk, and after must be procedures, and each should accept zero arguments. These procedures may return any number of values. The dynamic-wind procedure calls thunk without arguments, returning the results of this call. Moreover, dynamic-wind calls _before_without arguments whenever the dynamic extent of the call to thunk is entered, and after without arguments whenever the dynamic extent of the call to thunk is exited. Thus, in the absence of calls to escape procedures created by call-with-current-continuation, dynamic-wind calls before, thunk, and after, in that order.

Iteration

[R6RS] “Named let” is a variant on the syntax of let that provides a general looping construct and may also be used to express recursion. It has the same syntax and semantics as ordinary let except that _variable_is bound within body to a procedure whose parameters are the bound variables and whose body is body. Thus the execution of body may be repeated by invoking the procedure named by variable.

Quasiquote

[R6RS] "Quasiquote" expressions is useful for constructing a list or vector structure when some but not all of the desired structure is known in advance.

Qq-template should be as specified by the grammar at the end of this entry.

If no unquote or unquote-splicing forms appear within the qq-template, the result of evaluating (quasiquote _qq-template_)is equivalent to the result of evaluating (quote _qq-template_).

If an (unquote _expression_ ...) form appears inside a qq-template, however, the expressions are evaluated ("unquoted") and their results are inserted into the structure instead of the unquote form.

If an (unquote-splicing _expression_ ...) form appears inside a qq-template, then the expressions must evaluate to lists; the opening and closing parentheses of the lists are then "stripped away" and the elements of the lists are inserted in place of the unquote-splicing form.

Any unquote-splicing or multi-operand unquote form must appear only within a list or vector qq-template.

Note: even though unquote and unquote-splicing are bounded, however it does not work with import prefix nor renamed import. This may be fixed in future.

Binding constructs for syntactic keywords

The let-syntax and letrec-syntax forms bind keywords. On R6RS mode it works like a begin form, a let-syntax or letrec-syntaxform may appear in a definition context, in which case it is treated as a definition, and the forms in the body must also be definitions. A let-syntaxor letrec-syntax form may also appear in an expression context, in which case the forms within their bodies must be expressions.

[R6RS] Bindings must have the form

((_keyword_ _expression_) ...)

Each keyword is an identifier, and each expression is an expression that evaluates, at macro-expansion time, to a transformer. Transformers may be created by syntax-rules or identifier-syntax or by one of the other mechanisms described in library chapter on "syntax-case". It is a syntax violation for keyword to appear more than once in the list of keywords being bound.

The forms are expanded in the syntactic environment obtained by extending the syntactic environment of the let-syntax form with macros whose keywords are the keywords, bound to the specified transformers. Each binding of a keyword has the forms as its region.

[R6RS] Bindings must have the form

((_keyword_ _expression_) ...)

Each keyword is an identifier, and each expression is an expression that evaluates, at macro-expansion time, to a transformer. Transformers may be created by syntax-rules or identifier-syntax or by one of the other mechanisms described in library chapter on "syntax-case". It is a syntax violation for keyword to appear more than once in the list of keywords being bound.

The forms are expanded in the syntactic environment obtained by extending the syntactic environment of the letrec-syntax form with macros whose keywords are the keywords, bound to the specified transformers. Each binding of a keyword has the bindings as well as the forms within its region, so the transformers can transcribe forms into uses of the macros introduced by the letrec-syntax form.

Note: The forms of a let-syntax and a letrec-syntax form are treated, whether in definition or expression context, as if wrapped in an implicit begin on R6RS mode, it is, then, treated as if wrapped in an implicit let on compatible mode. Thus on compatible mode, it creates a scope.

Macro transformers

In R6RS, it requires '_' '...' as bounded symbols but in Sagittarius these are not bound. And if import clause has rename or prefix these auxiliary syntax are not be renamed or prefixed. This behaivour may be fixed in future.

[R6RS] Each literal must be an identifier. Each rule must have the following form:

(srpattern template)

An srpattern is a restricted form of pattern, namely, a nonempty pattern in one of four parenthesized forms below whose first subform is an identifier or an underscore _. A pattern is an identifier, constant, or one of the following.

• (pattern ...)

• (pattern pattern ... . pattern)

• (pattern ... pattern ellipsis pattern ...)

• (pattern ... pattern ellipsis pattern ... . pattern)

• #(pattern ...)

• #(pattern ... pattern ellipsis pattern ...)

An ellipsis is the identifier "..." (three periods).

A template is a pattern variable, an identifier that is not a pattern variable, a pattern datum, or one of the following.

• (subtemplate ...)

• (subtemplate ... . template)

• #(subtemplate ...)

A subtemplate is a template followed by zero or more ellipses.

An instance of syntax-rules evaluates, at macro-expansion time, to a new macro transformer by specifying a sequence of hygienic rewrite rules. A use of a macro whose keyword is associated with a transformer specified by syntax-rulesis matched against the patterns contained in the rules, beginning with the leftmost rule. When a match is found, the macro use is transcribed hygienically according to the template. It is a syntax violation when no match is found.

[R6RS] The ids must be identifiers. The templates must be as for syntax-rules.

When a keyword is bound to a transformer produced by the first form of identifier-syntax, references to the keyword within the scope of the binding are replaced by template.

(define p (cons 4 5))

(define-syntax p.car (identifier-syntax (car p)))

p.car

(set! p.car 15)

The second, more general, form of identifier-syntax permits the transformer to determine what happens when set! is used. In this case, uses of the identifier by itself are replaced by template1, and uses of set! with the identifier are replaced by template2

(define p (cons 4 5))

(define-syntax p.car
  (identifier-syntax
    (_ (car p))
    ((set! _ e) (set-car! p e))))

(set! p.car 15)

p.car

p

Characters

[R6RS] These procedures take a character argument and return a character result. If the argument is an upper-case or title-case character, and if there is a single character that is its lower-case form, then char-downcasereturns that character. If the argument is a lower-case or title-case character, and there is a single character that is its upper-case form, then char-upcasereturns that character. If the argument is a lower-case or upper-case character, and there is a single character that is its title-case form, then char-titlecasereturns that character. If the argument is not a title-case character and there is no single character that is its title-case form, then char-titlecasereturns the upper-case form of the argument. Finally, if the character has a case-folded character, then char-foldcase returns that character. Otherwise the character returned is the same as the argument. For Turkic characters İ (#\x130) and ı (#\x131), char-foldcase behaves as the identity function; otherwise char-foldcase is the same as char-downcase composed with char-upcase.

[R6RS] These procedures are similar to char=?, etc., but operate on the case-folded versions of the characters.

[R6RS] These procedures return #t if their arguments are alphabetic, numeric, whitespace, upper-case, lower-case, or title-case characters, respectively; otherwise they return #f.

A character is alphabetic if it has the Unicode "Alphabetic" property. A character is numeric if it has the Unicode "Numeric" property. A character is whitespace if has the Unicode "White_Space" property. A character is upper case if it has the Unicode "Uppercase" property, lower case if it has the "Lowercase" property, and title case if it is in the Lt general category.

[R6RS] Returns a symbol representing the Unicode general category of char, one of Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Ps, Pe, Pi, Pf, Pd, Pc, Po, Sc, Sm, Sk, So, Zs, Zp, Zl, Cc, Cf, Cs, Co, or Cn.

Strings

[R6RS+][SRFI-13] These procedures take a string argument and return a string result. They are defined in terms of Unicode's locale-independent case mappings from Unicode scalar-value sequences to scalar-value sequences. In particular, the length of the result string can be different from the length of the input string. When the specified result is equal in the sense of string=? to the argument, these procedures may return the argument instead of a newly allocated string.

The string-upcase procedure converts a string to upper case; string-downcase converts a string to lower case.

The string-foldcase procedure converts the string to its case-folded counterpart, using the full case-folding mapping, but without the special mappings for Turkic languages.

The string-titlecase procedure converts the first cased character of each word via char-titlecase, and downcases all other cased characters.

If the optional argument start and end are given, these must be exact integer and the procedures will first substring the given string with range start and end then convert it.

[R6RS] These procedures are similar to string=?, etc., but operate on the case-folded versions of the strings.

[R6RS] These procedures take a string argument and return a string result, which is the input string normalized to Unicode normalization form D, KD, C, or KC, respectively. When the specified result is equal in the sense of string=?to the argument, these procedures may return the argument instead of a newly allocated string.

General operations

[R6RS] The name of symbol must be a symbol describing an endianness. (endianness _symbol_) evaluates to the symbol named symbol. Whenever one of the procedures operating on bytevectors accepts an endianness as an argument, that argument must be one of these symbols. It is a syntax violation for symbol to be anything other than an endianness symbol supported by the Sagittarius.

Currently, Sagittarius supports these symbols; big, littleand native.

[R6RS] Returns the endianness symbol associated platform endianness. This may be a symbol either big or little.

[R6RS] Returns #t if obj is a bytevector, otherwise returns #f.

[R6RS] Returns a newly allocated bytevector of k bytes.

If the fill argument is missing, the initial contents of the returned bytevector are 0.

If the fill argument is present, it must be an exact integer object in the interval {-128, ..., 255} that specifies the initial value for the bytes of the bytevector: If fill is positive, it is interpreted as an octet; if it is negative, it is interpreted as a byte.

[R6RS] Returns, as an exact integer object, the number of bytes in bytevector.

[R6RS] Returns #t if bytevector1 and bytevector2 are equal-that is, if they have the same length and equal bytes at all valid indices. It returns #f otherwise.

[R6RS+] The fill argument is as in the description of the make-bytevector procedure. The bytevector-fill! procedure stores fill in every element of bytevector and returns unspecified values. Analogous to vector-fill!.

If optional arguments start or end is given, then the procedure restricts the range of filling from start to end (exclusive) index of bytevector. When end is omitted then it uses the length of the given bytevector.

[R6RS] Source and target must be bytevectors. Source-start, target-start, and k must be non-negative exact integer objects that satisfy

0 <= source-start <= source-start + k <= _source-length_0 <= target-start <= target-start + k <= _target-length_where source-length is the length of source and _target-length_is the length of target.

The bytevector-copy! procedure copies the bytes from source at indices

source-start, ... source-start + k - 1

to consecutive indices in target starting at target-index.

This returns unspecified values.

_ :optional (start 0) (end -1)

[R6RS+] Returns a newly allocated copy of bytevector.

If optional argument start was given, the procedure copies from the given start index.

If optional argument end was given, the procedure copies to the given end index (exclusive).

Operation on bytes and octets

[R6RS] K must be a valid index of bytevector.

The bytevector-u8-ref procedure returns the byte at index k of bytevector, as an octet.

The bytevector-s8-ref procedure returns the byte at index k of bytevector, as a (signed) byte.

[R6RS] K must be a valid index of bytevector.

The bytevector-u8-set! procedure stores octet in element _k_of bytevector.

The bytevector-s8-set! procedure stores the two's-complement representation of byte in element k of bytevector.

Both procedures return unspecified values.

[R6RS] List must be a list of octets.

The bytevector->u8-list procedure returns a newly allocated list of the octets of bytevector in the same order.

The u8-list->bytevector procedure returns a newly allocated bytevector whose elements are the elements of list list, in the same order. It is analogous to list->vector.

Operations on integers of arbitary size

[R6RS] Size must be a positive exact integer object. K, ..., k + size - 1 must be valid indices of bytevector.

The bytevector-uint-ref procedure retrieves the exact integer object corresponding to the unsigned representation of size size and specified by endianness at indices k, ..., k + size - 1.

The bytevector-sint-ref procedure retrieves the exact integer object corresponding to the two's-complement representation of size size and specified by endianness at indices k, ..., k + size - 1.

For bytevector-uint-set!, n must be an exact integer object in the interval _{0, ..., 256 ^ "size" - 1}_The bytevector-uint-set! procedure stores the unsigned representation of size size and specified by endianness into bytevector at indices k, ..., k + size - 1.

For bytevector-sint-set!, n must be an exact integer object in the interval {-256 ^ "size" / 2, ..., 256 ^ "size" / 2 - 1}. bytevector-sint-set! stores the two's-complement representation of size size and specified by endianness into bytevector at indices k, ..., k + size - 1.

The ...-set! procedures return unspecified values.

[R6RS] Size must be a positive exact integer object. For uint-list->bytevector, list must be a list of exact integer objects in the interval {0, ..., 256 ^ "size" - 1}. For sint-list->bytevector, list must be a list of exact integer objects in the interval {-256 ^ "size"/2, ..., 256 ^ "size"/2 - 1}. The length of _bytevector_or, respectively, of list must be divisible by size.

These procedures convert between lists of integer objects and their consecutive representations according to size and endianness in the _bytevector_objects in the same way as bytevector->u8-list and u8-list->bytevectordo for one-byte representations.

Operation on 16-bit integers

[R6RS] K must be a valid index of bytevector; so must k + 1. For bytevector-u16-set! and bytevector-u16-native-set!, _n_must be an exact integer object in the interval {0, ..., 2 ^ 16 - 1}. For bytevector-s16-set! and bytevector-s16-native-set!, _n_must be an exact integer object in the interval {-2 ^ 15, ..., 2 ^ 15 - 1}.

These retrieve and set two-byte representations of numbers at indices _k_and k + 1, according to the endianness specified by endianness. The procedures with u16 in their names deal with the unsigned representation; those with s16 in their names deal with the two's-complement representation.

The procedures with native in their names employ the native endianness, and work only at aligned indices: k must be a multiple of 2.

The ...-set! procedures return unspecified values.

Operation on 32-bit integers

[R6RS] K must be a valid index of bytevector; so must k + 3. For bytevector-u32-set! and bytevector-u32-native-set!, _n_must be an exact integer object in the interval {0, ..., 2 ^ 32 - 1}. For bytevector-s32-set! and bytevector-s32-native-set!, _n_must be an exact integer object in the interval {-2 ^ 31, ..., 2 ^ 32 - 1}.

These retrieve and set two-byte representations of numbers at indices _k_and k + 3, according to the endianness specified by endianness. The procedures with u32 in their names deal with the unsigned representation; those with s32 in their names deal with the two's-complement representation.

The procedures with native in their names employ the native endianness, and work only at aligned indices: k must be a multiple of 4.

The ...-set! procedures return unspecified values.

Operation on 64-bit integers

[R6RS] K must be a valid index of bytevector; so must k + 7. For bytevector-u64-set! and bytevector-u64-native-set!, _n_must be an exact integer object in the interval {0, ..., 2 ^ 64 - 1}. For bytevector-s64-set! and bytevector-s64-native-set!, _n_must be an exact integer object in the interval {-2 ^ 63, ..., 2 ^ 64 - 1}.

These retrieve and set two-byte representations of numbers at indices _k_and k + 7, according to the endianness specified by endianness. The procedures with u64 in their names deal with the unsigned representation; those with s64 in their names deal with the two's-complement representation.

The procedures with native in their names employ the native endianness, and work only at aligned indices: k must be a multiple of 8.

The ...-set! procedures return unspecified values.

Operation on IEEE-754 representations

[R6RS] K, …, k + 3 must be valid indices of bytevector. For bytevector-ieee-single-native-ref, k must be a multiple of 4.

These procedures return the inexact real number object that best represents the IEEE-754 single-precision number represented by the four bytes beginning at index k.

[R6RS] K, …, k + 7 must be valid indices of bytevector. For bytevector-ieee-double-native-ref, k must be a multiple of 8.

These procedures return the inexact real number object that best represents the IEEE-754 double-precision number represented by the four bytes beginning at index k.

[R6RS] K, …, k + 3 must be valid indices of bytevector. For bytevector-ieee-single-native-set!, k must be a multiple of 4.

These procedures store an IEEE-754 single-precision representation of _x_into elements k through k + 3 of bytevector, and return unspecified values.

[R6RS] K, …, k + 7 must be valid indices of bytevector. For bytevector-ieee-double-native-set!, k must be a multiple of 8.

These procedures store an IEEE-754 double-precision representation of _x_into elements k through k + 7 of bytevector, and return unspecified values.

Operation on strings

This section describes procedures that convert between strings and bytevectors containing Unicode encodings of those strings. When decoding bytevectors, encoding errors are handled as with the replace semantics of textual I/O: If an invalid or incomplete character encoding is encountered, then the replacement character U+FFFD is appended to the string being generated, an appropriate number of bytes are ignored, and decoding continues with the following bytes.

[R6RS+] [R7RS] Returns a newly allocated (unless empty) bytevector that contains the UTF-8 encoding of the given string.

If the optional argument start is given, the procedure converts given string from start index (inclusive).

If the optional argument end is given, the procedure converts given string to end index (exclusive).

These optional arguments must be fixnum if it's given.

[R6RS] If endianness is specified, it must be the symbol bigor the symbol little. The string->utf16 procedure returns a newly allocated (unless empty) bytevector that contains the UTF-16BE or UTF-16LE encoding of the given string (with no byte-order mark). If _endianness_is not specified or is big, then UTF-16BE is used. If endianness is little, then UTF-16LE is used.

[R6RS] If endianness is specified, it must be the symbol bigor the symbol little. The string->utf32 procedure returns a newly allocated (unless empty) bytevector that contains the UTF-32BE or UTF-32LE encoding of the given string (with no byte-order mark). If _endianness_is not specified or is big, then UTF-32BE is used. If endianness is little, then UTF-32LE is used.

[R6RS] Returns a newly allocated (unless empty) string whose character sequence is encoded by the given bytevector.

If the optional argument start is given, the procedure converts given string from start index (inclusive).

If the optional argument end is given, the procedure converts given string to end index (exclusive).

These optional arguments must be fixnum if it's given.

[R6RS] Endianness must be the symbol big or the symbol little. The utf16->string procedure returns a newly allocated (unless empty) string whose character sequence is encoded by the given bytevector. Bytevector is decoded according to UTF-16BE or UTF-16LE: If endianness-mandatory? is absent or #f, utf16->string determines the endianness according to a UTF-16 BOM at the beginning of _bytevector_if a BOM is present; in this case, the BOM is not decoded as a character. Also in this case, if no UTF-16 BOM is present, endianness specifies the endianness of the encoding. If endianness-mandatory? is a true value, _endianness_specifies the endianness of the encoding, and any UTF-16 BOM in the encoding is decoded as a regular character.

[R6RS] Endianness must be the symbol big or the symbol little. The utf32->string procedure returns a newly allocated (unless empty) string whose character sequence is encoded by the given bytevector. Bytevector is decoded according to UTF-32BE or UTF-32LE: If endianness-mandatory? is absent or #f, utf32->string determines the endianness according to a UTF-32 BOM at the beginning of _bytevector_if a BOM is present; in this case, the BOM is not decoded as a character. Also in this case, if no UTF-32 BOM is present, endianness specifies the endianness of the encoding. If endianness-mandatory? is a true value, _endianness_specifies the endianness of the encoding, and any UTF-32 BOM in the encoding is decoded as a regular character.

Standard condition types

Hierarchy of standard condition types:

+ &condition
    + &warning
    + &serious
          + &error
          + &violation
                + &assertion
                + &non-continuable
                + &implementation-restriction
                + &lexical
                + &syntax
                + &undefined
    + &message
    + &irritants

[R6RS] It carries a message further describing the nature of the condition to humans.

[R6RS] This type describes conditions that do not, in principle, prohibit immediate continued execution of the program, but may interfere with the program's execution later.

[R6RS] This type describes conditions serious enough that they cannot safely be ignored. This condition type is primarily intended as a supertype of other condition types.

[R6RS] This type describes errors, typically caused by something that has gone wrong in the interaction of the program with the external world or the user.

[R6RS] This type describes violations of the language standard or a library standard, typically caused by a programming error.

[R6RS] This type describes an invalid call to a procedure, either passing an invalid number of arguments, or passing an argument of the wrong type.

[R6RS] Irritants should be a list of objects. This condition provides additional information about a condition, typically the argument list of a procedure that detected an exception. Conditions of this type are created by the error and assertion-violation procedures.

[R6RS] Who should be a symbol or string identifying the entity reporting the exception. Conditions of this type are created by the errorand assertion-violation procedures, and the syntax-violationprocedure.

[R6RS] This type indicates that an exception handler invoked via raise has returned.

[R6RS] This type describes a violation of an implementation restriction allowed by the specification, such as the absence of representations for NaNs and infinities.

[R6RS] This type describes syntax violations at the level of the datum syntax.

[R6RS] This type describes syntax violations. Form should be the erroneous syntax object or a datum representing the code of the erroneous form. Subform should be an optional syntax object or datum within the erroneous form that more precisely locates the violation. It can be #f to indicate the absence of more precise information.

[R6RS] This type describes unbound identifiers in the program.

Port I/O

The (rnrs io ports (6))library defines an I/O layer for conventional, imperative buffered input and output. A port represents a buffered access object for a data sink or source or both simultaneously. The library allows ports to be created from arbitrary data sources and sinks.

The (rnrs io ports (6)) library distinguishes between _input ports_and output ports. An input port is a source for data, whereas an output port is a sink for data. A port may be both an input port and an output port; such a port typically provides simultaneous read and write access to a file or other data.

The (rnrs io ports (6)) library also distinguishes between binary ports, which are sources or sinks for uninterpreted bytes, and textual ports, which are sources or sinks for characters and strings.

This section uses input-port, output-port, binary-port, textual-port, binary-input-port, textual-input-port, binary-output-port, textual-output-port, and port as parameter names for arguments that must be input ports (or combined input/output ports), output ports (or combined input/output ports), binary ports, textual ports, binary input ports, textual input ports, binary output ports, textual output ports, or any kind of port, respectively.

(open-bytevector-input-port (bytevector-copy bytevector start end))

(open-string-input-port (substring string start end))