Mosh User's Reference

The eqv? procedure defines a useful equivalence relation on objects.

Briefly, it returns #t if obj1 and obj2 should normally be regarded as the same object and #f otherwise.

The eqv? procedure returns #t if one of the following holds:

Obj1 and obj2 are both booleans and are the same according to the boolean=? procedure.

Obj1 and obj2 are both symbols and are the same according to the symbol=? procedure.

Obj1 and obj2 are both exactnumber objects and are numerically equal.

Obj1 and obj2 are both inexactnumber objects, are numerically equal, and yield the same results (in the sense of eqv?) when passed as arguments to any other procedure that can be defined as a finite composition of Scheme's standard arithmetic procedures.

Obj1 and obj2 are both characters and are the same character according to the char=? procedure .

Both obj1 and obj2 are the empty list.

Obj1 and obj2 are objects such as pairs, vectors, bytevectors , strings, hashtables, records, ports, or hashtables that refer to the same locations in the store.

Obj1 and obj2 are record-type descriptors that are specified to be eqv? in library.

The eqv? procedure returns #f if one of the following holds:

Obj1 and obj2 are of different types.

Obj1 and obj2 are booleans for which the boolean=? procedure returns #f.

Obj1 and obj2 are symbols for which the symbol=? procedure returns #f.

One of obj1 and obj2 is an exact number object but the other is an inexact number object.

Obj1 and obj2 are rational number objects for which the = procedure returns #f.

Obj1 and obj2 yield different results (in the sense of eqv?) when passed as arguments to any other procedure that can be defined as a finite composition of Scheme's standard arithmetic procedures.

Obj1 and obj2 are characters for which the char=? procedure returns #f.

One of obj1 and obj2 is the empty list, but the other is not.

Obj1 and obj2 are objects such as pairs, vectors, bytevectors (library chapter on "Bytevectors"), strings, records (library chapter on "Records"), ports, or hashtables that refer to distinct locations.

Obj1 and obj2 are pairs, vectors, strings, or records, or hashtables, where the applying the same accessor (i.e. car, cdr, vector-ref, string-ref, or record accessors) to both yields results for which eqv? returns #f.

Obj1 and obj2 are procedures that would behave differently (return different values or have different side effects) for some arguments.

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.

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 is evaluated and its values are returned.

If yields #f and no [alternate] is specified, then the result of the expression is unspecified.

(let [bindings] [body])

Syntax: [Bindings] must have the form

(([variable1] [init1]) ...),

where each [init] is an expression.

Any variable must not appear more than once in the [variable]s.

(let* [bindings] [body])

Syntax: [Bindings] must have the form

(([variable1] [init1]) ...),

Semantics: The let* form is similar to let, but the [init]s are evaluated and bindings created sequentially from left to right, with the regionof 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.

(letrec [bindings] [body])

Syntax: [Bindings] must have the form

(([variable1] [init1]) ...),

Any variable must not appear more than once in the [variable]s.

Semantics: The [variable]s are bound to fresh locations, 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 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 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.

[Expression] is evaluated, and the resulting value is stored in the location to which [variable] is bound.

[Variable] must be bound either in some regionenclosing the set! expression or at the top level.

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.

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 [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.

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 at that later time and will instead reinstate the continuation that was in effect when the escape procedure was created.

case expression is evaluated as follows.

[Key] is evaluated and its result is compared using eqv? against the data represented by the [datum]s of each [case 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 [case clause], the corresponding [expression]s are evaluated from left to right and the results of the last expression in the [case 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.

A cond expression is evaluated by evaluating the [test] expressions of successive [cond clause]s in order until one of them evaluates to a true value.

When a [test] evaluates to a true value, then the remaining [expression]s in its [cond clause] are evaluated in order, and the results of the last [expression] in the [cond clause] are returned as the results of the entire cond expression.

If the selected [cond clause] contains only the [test] and no [expression]s, then the value of the [test] is returned as the result. If the selected [cond 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 [test]s evaluate to #f, and there is no else clause, then the conditional expression returns unspecified values; if there is an else clause, then its [expression]s are evaluated, and the values of the last one are returned.

The eq? predicate is similar to eqv? except that in some cases it is capable of discerning distinctions finer than those detectable by eqv?.

The eq? and eqv? predicates are guaranteed to have the same behavior on symbols, booleans, the empty list, pairs, procedures, non-empty strings, bytevectors, and vectors, and records.

Returns #t if the strings are the same length and contain the same characters in the same positions.

Otherwise, the string=? procedure returns #f.Returns #t if obj is a string, otherwise returns #f.

The fold-left procedure iterates the combine procedure over an accumulator value and the elements of the lists from left to right, starting with an accumulator value of nil.

More specifically, fold-left returns nil if the lists are empty. If they are not empty, combine is first applied to nil and the respective first elements of the lists in order.

The result becomes the new accumulator value, and combine is applied to the new accumulator value and the respective next elements of the list.

This step is repeated until the end of the list is reached; then the accumulator value is returned. Combine is always called in the same dynamic environment as fold-left itself.

The filter procedure applies proc to each element of list and returns a list of the elements of list for which proc returned a true value.

The elements of the result list(s) are in the same order as they appear in the input list.

The find procedure applies proc to the elements of list in order. If proc returns a true value for an element, find immediately returns that element. If proc returns #f for all elements of the list, find returns #f.

Find the first pair in alist whose car field satisfies a given condition, and returns that pair without traversing alist further. If no pair in alist satisfies the condition, then #f is returned.

The assoc procedure uses equal? to compare obj with the car fields of the pairs in alist, while assv uses eqv? and assq uses eq?.

Find the first pair in alist whose car field satisfies a given condition, and returns that pair without traversing alist further. If no pair in alist satisfies the condition, then #f is returned.

The assoc procedure uses equal? to compare obj with the car fields of the pairs in alist, while assv uses eqv? and assq uses eq?.

The [init] expressions are evaluated (in some unspecified order), the [variable]s are bound to fresh locations, the results of the [init] expressions are stored in the bindings of the [variable]s, and then the iteration phase begins.

Each iteration begins by evaluating [test]; if the result is #f, then the [command]s are evaluated in order for effect, the [step] expressions are evaluated in some unspecified order, the [variable]s are bound to fresh locations holding the results, and the next iteration begins.

If [test] evaluates to a true value, the [expression]s are evaluated from left to right and the values of the last [expression] are returned.

If no [expression]s are present, then the do expression returns unspecified values.

The regionof the binding of a [variable] consists of the entire do expression except for the [init]s.

A [step] may be omitted, in which case the effect is the same as if ([variable] [init] [variable]) had been written instead of ([variable] [init]).

(guard ([variable] syntax

[cond clause1] [cond clause2] ...)

[body])

=> auxiliary syntax

else auxiliary syntax

Semantics: Evaluating a guard form evaluates [body] with an exception handler that binds the raised object to [variable] and within the scope of that binding evaluates the clauses as if they were the clauses of a cond expression.

That implicit cond expression is evaluated with the continuation and dynamic environment of the guard expression.

If every [cond clause]'s [test] evaluates to #f and there is no else clause, then raise is re-invoked on the raised object within the dynamic environment of the original call to raise except that the current exception handler is that of the guard expression.

Raises a continuable exception by invoking the current exception handler on obj.

The handler is called with a continuation that is equivalent to the continuation of the call to raise-continuable, with these two exceptions:

(1) the current exception handler is the one that was in place when the handler being called was installed, and (2) if the handler being called returns, then it will again become the current exception handler.

If the handler returns, the values it returns become the values returned by the call to raise-continuable.

Reads from binary-input-port, blocking as necessary, until count bytes are available from binary-input-port or until an end of file is reached.

If count bytes are available before an end of file, get-bytevector-n returns a bytevector of size count. If fewer bytes are available before an end of file, get-bytevector-n returns a bytevector containing those bytes.

In either case, the input port is updated to point just past the bytes read.

If an end of file is reached before any bytes are available, get-bytevector-n returns the end-of-file object.

Returns a new textual port with the specified transcoder.

Otherwise the new textual port's state is largely the same as that of binary-port.

If binary-port is an input port, the new textual port will be an input port and will transcode the bytes that have not yet been read from binary-port. If binary-port is an output port, the new textual port will be an output port and will transcode output characters into bytes that are written to the byte sink represented by binary-port.

Reads from binary-input-port, blocking as necessary, until a byte is available from binary-input-port or until an end of file is reached.

If a byte becomes available, get-u8 returns the byte as an octet and updates binary-input-port to point just past that byte. If no input byte is seen before an end of file is reached, the end-of-file object is returned.

Note. This procedure is not implementednot all specification.

Returns a newly created binary input port whose byte source is an arbitrary algorithm represented by the read! procedure.

Id must be a string naming the new port, provided for informational purposes only. Read! must be a procedure and should behave as specified below; it will be called by operations that perform binary input.

Each of the remaining arguments may be #f; if any of those arguments is not #f, it must be a procedure and should behave as specified below.

(read! bytevector start count)

Start will be a non-negative exact integer object, count will be a positive exact integer object, and bytevector will be a bytevector whose length is at least start + count.

The read! procedure should obtain up to count bytes from the byte source, and should write those bytes into bytevector starting at index start.

The read! procedure should return an exact integer object.

This integer object should represent the number of bytes that it has read. To indicate an end of file, the read! procedure should write no bytes and return 0.

(get-position)

The get-position procedure (if supplied) should return an exact integer object representing the current position of the input port.

If not supplied, the custom port will not support the port-position operation.

(set-position! pos)

Pos will be a non-negative exact integer object. The set-position! procedure (if supplied) should set the position of the input port to pos.

If not supplied, the custom port will not support the set-port-position! operation.

(close)

The close procedure (if supplied) should perform any actions that are necessary when the input port is closed.

Reads from textual-input-port, blocking as necessary until a character is available from textual-input-port, or the data that are available cannot be the prefix of any valid encoding, or an end of file is reached.

If a complete character is available before the next end of file, read-char returns that character, and updates the input port to point past that character. If an end of file is reached before any data are read, read-char returns the end-of-file object. If textual-input-port is omitted, it defaults to the value returned by current-input-port.

Open the file named by filename for output, with no specified file options, and call proc with the obtained port as an argument.

If proc returns, the port is closed automatically and the values returned by proc are returned. If proc does not return, the port is not closed automatically, unless it is possible to prove that the port will never again be used for an I/O operation.

Open the file named by filename for input, with no specified file options, and call proc with the obtained port as an argument.

If proc returns, the port is closed automatically and the values returned by proc are returned. If proc does not return, the port is not closed automatically, unless it is possible to prove that the port will never again be used for an I/O operation.

Returns two values: a textual output port and an extraction procedure.

The output port accumulates the characters written to it for later extraction by the procedure.

The extraction procedure takes no arguments.

When called, it returns a string consisting of all of the port's accumulated characters (regardless of the current position),removes the accumulated characters from the port, and resetsthe port's position

Creates a textual output port that accumulates the characters written to it and calls proc with that output port as an argument.

Whenever proc returns, a string consisting of all of the port's accumulated characters (regardless of the port's current position) is returned and the port is closed.

Creates an output port that accumulates the bytes written to it and calls proc with that output port as an argument.

Whenever proc returns, a bytevector consisting of all of the port's accumulated bytes (regardless of the port’s currentposition) is returned and the port is closed.

Returns two values: an output port and an extraction procedure.

The output port accumulates the bytes written to it for later extraction by the procedure.

If transcoder is a transcoder, it becomes the transcoder associated with the port. If maybe-transcoder is #f or absent, the port will be a binary port and will support the port-position and set-port-position! operations.

The extraction procedure takes no arguments. When called, it returns a bytevector consisting of all the port's accumulated bytes (regardless of the port’s current position), removes the accumulated bytes from the port, and resets the port's position.

Writes a representation of obj to the given textual-output-port.

Strings that appear in the written representation are not enclosed in doublequotes, and no characters are escaped within those strings.

Character objects appear in the representation as if written by write-char instead of by write.

The textual-output-port argument may be omitted, in which case it defaults to the value returned by current-output-port.

This is equivalent to using write-char to write #\linefeed to textual-output-port. If textual-output-port is omitted, it defaults to the value returned by current-output-port.

Returns a newly allocated mutable hashtable that accepts arbitrary objects as keys, and compares those keys with eq?. If an argument is given, the initial capacity of the hashtable is set to approximately k elements.

Evaluates expression in the specified environment and returns its value.

Note that currently the environment argument is ignored.

Regexp is a regular expression object. A string string is matched by regexp. If it matches, the function returns a [regmatch] object. Otherwise it returns #f.

You can use (#/regexp/ string) style instead of (rxmatch #/regexp/ string).

If i equals to zero, the functions return start of entire match. With positive integer I, it returns those of I-th submatches.

It is an error to pass other values to I. It is allowed to pass #f to match for convenience. The functions return #f in such case.

If i equals to zero, the functions return end of entire match. With positive integer I, it returns those of I-th submatches.

It is an error to pass other values to I. It is allowed to pass #f to match for convenience. The functions return #f in such case.

If i equals to zero, the functions return substring of entire match. With positive integer I, it returns those of I-th submatches.

It is an error to pass other values to I. It is allowed to pass #f to match for convenience. The functions return #f in such case.

Convenient string I/O procedure.

(define (call-with-string-io str proc)
 (receive (out get-string) (open-string-output-port)
 (let1 in (open-string-input-port str)
 (proc in out)
 (get-string))))

This is the way to receive multiple values.

Formals can be a (maybe-improper) list of symbols.

Expression is evaluated, and the returned value(s) are bound to formals like the binding of lambda formals, then body ... are evaluated.

Format arg ... according to string.

port specifies the destination;

if it is an output port, the formatted result is written to it;

if it is #t, the result is written to the current output port;

if it is #f, the formatted result is returned as a string.

Port can be omitted, as SRFI-28 format; it has the same effects as giving #f to the port.

string is a string that contains format directives.

A format directive is a character sequence begins with tilda, `~', and ends with some specific characters.

The rest of string is copied to the output as is.

Currently supported directive is ~a/~A (The corresponding argument is printed by display.), ~s/~S (The corresponding argument is printed by write.)