Big Scheme

Big Scheme is a set of generally useful facilities.

Easiest way to access these things:

    > ,open big-scheme
    Load structure big-scheme (y/n)? y
    ...

Ascii conversions

(CHAR->ASCII <char>) => <integer>
(ASCII->CHAR <integer>) => <char>

These are identical to CHAR->INTEGER and INTEGER->CHAR except that they use the ASCII encoding.

Bitwise operations

(BITWISE-NOT <integer>) => <integer>
(BITWISE-AND <integer> <integer>) => <integer>
(BITWISE-IOR <integer> <integer>) => <integer>
(BITWISE-XOR <integer> <integer>) => <integer>

These perform various logical operations on integers on a bit-by-bit basis, using a two's-complement representation.

(ARITHMETIC-SHIFT <integer> <bit-count>) => <integer>

Shift the integer by the given bit count, shifting left for positive counts and right for negative ones. A two's complement representation is used.

Hash tables

(MAKE-TABLE) => <table>
(MAKE-STRING-TABLE) => <string-table>

Make a new, empty table. MAKE-TABLE returns a table that uses EQ? for comparing keys and an ad-hoc hash function. String tables uses strings for keys.

(MAKE-TABLE-MAKER <comparison-procedure> <hash-procedure>) => <procedure>

Returns a procedure of no arguments that makes tables that use the given comparison and hash procedures. (<comparison-procedure> <key1> <key2>) => <boolean> (<hash-procedure> <key>) => <non-negative-integer>

(TABLE? <x>) => <boolean>

True if <x> is a table.

(TABLE-REF <table> <key>) => <x>

Return the value for <key> in <table>, or #F if there is none. <key> should be of a type appropriate for <table>.

(TABLE-SET! <table> <key> <value>) => <undefined>

Make <value> be the value of <key> in <table>. <key> should be of a type appropriate for <table>.

(TABLE-WALK <procedure> <table>) => <undefined>

Apply <procedure>, which must accept two arguments, to every associated key and value in <table>.

Enumerations

(DEFINE-ENUMERATION <type-name> (<name0> <name1> ...)) *SYNTAX*

Defines <type-name> to be an enumeration with components <name0> <name1> .... Also defines <type-name>-COUNT to be the number of components.

(ENUM <type-name> <component-name>) => <integer> *SYNTAX*

Evaluates to the value of <component-name> within the enumeration <type-name>. For example, if (DEFINE-ENUMERATION COLOR (GREEN RED)), then (ENUM COLOR GREEN) is zero and (ENUM COLOR RED) is one. The mapping from name to integer is done at macro-expansion time, so there is no run-time overhead.

(ENUMERAND->NAME <integer> <enumeration>) => <symbol>

Returns the name associated with <integer> within <enumeration>. E.g. (ENUMERAND->NAME 1 COLOR) => 'RED.

(NAME->ENUMERAND <symbol> <enumeration>) => <integer>

Returns the integer associated with <symbol> within <enumeration>. E.g. (ENUMERAND->NAME 'GREEN COLOR) => 0.

Port extensions

(MAKE-TRACKING-INPUT-PORT <input-port>) => <input-port>
(MAKE-TRACKING-OUTPUT-PORT <output-port>) => <output-port>

These return ports that keep track of the current row and column and are otherwise identical to their arguments.

(MAKE-STRING-INPUT-PORT <string>) => <input-port>

Returns a port that reads characters from the supplied string.

(CALL-WITH-STRING-OUTPUT-PORT <procedure>) => <string>

The procedure is called on a port. When it returns, CALL-WITH-STRING- OUTPUT-PORT returns a string containing the characters written to the port.

(WRITE-ONE-LINE <output-port> <character-count> <procedure>) => <unspecified>

The procedure is called on an output port. Output written to that port is copied to until <character-count> characters have been written, at which point WRITE-ONE-LINE returns.

(CURRENT-ROW <port>) => <integer> or #f
(CURRENT-COLUMN <port>) => <integer> or #f

These return the current read or write location of the port. #F is returned if the port does not keep track of its location.

(FRESH-LINE <output-port>) => <undefined>

Write a newline character to <output-port> if its current column is not 0.

(INPUT-PORT? <any>) => <boolean>
(OUTPUT-PORT? <any>) => <boolean>

These are versions of the standard Scheme predicates that answer true for extended ports.

Queues

(MAKE-QUEUE) => <queue>

Returns a new, empty queue.

(ENQUEUE! <queue> <x>) => <undefined>

Puts <x> on the queue.

(DEQUEUE! <queue>) => <x>

Removes and returns the first element of the queue.

(QUEUE-EMPTY? <queue>) => <boolean>

True if the queue is empty.

(QUEUE? <x>) => <boolean>

True if <x> is a queue.

(QUEUE->LIST <queue>) => <list>

Returns a list of the elements of the queue, in order.

(QUEUE-LENGTH <queue>) => <integer>

The number of elements currently on the queue.

(DELETE-FROM-QUEUE! <queue> <x>) => <boolean>

Removes the first occurance of <x> from the queue, returning true if it was found and false otherwise.

Little utility procedures

(ATOM? <any>) => <boolean>

(ATOM? x) == (NOT (PAIR? x))

(NULL-LIST? <list>) => <boolean>

Returns #t for the empty list, #f for a pair, and signals an error otherwise.

(NEQ? <any> <any>) => <boolean>

(NEQ? x y) is the same as (NOT (EQ? x y)).

(N= <number> <number>) => <boolean>

(N= x y) is the same as (NOT (= x y)).

(IDENTITY <any>) => <any>
(NO-OP <any>) => <any>

These both just return their argument. NO-OP is guaranteed not to be compiled in-line, IDENTITY may be.

List utilities

(MEMQ? <element> <list>) => <boolean>

Returns true if <element> is in <list>, false otherwise.

(ANY? <predicate> <list>) => <boolean>

Returns true if <predicate> is true for any element of <list>.

(EVERY? <predicate> <list>) => <boolean>

Returns true if <predicate> is true for every element of <list>.

(ANY <predicate> <list>)
(FIRST <predicate> <list>)

ANY returns some element of <list> for which <predicate> is true, or #F if there are none. FIRST does the same except that it returns the first element for which is true.

(FILTER <predicate> <list>)
(FILTER! <predicate> <list>)

Returns a list containing all of the elements of <list> for which is true. The order of the elements is preserved. FILTER! may reuse the storage of <list>.

(FILTER-MAP <list>)

The same as FILTER except the returned list contains the results of applying <procedure> instead of elements of <list>. (FILTER-MAP p l) is the same as (FILTER IDENTITY (MAP p l)).

(PARTITION-LIST <predicate> <list>) => <list>
(PARTITION-LIST! <predicate> <list>) => <list> <list>

The first return value contains those elements for which <predicate> is true, the second contains the remaining elements. The order of the elements is preserved. PARTITION-LIST! may resuse the storage of the <list>.

(REMOVE-DUPLICATES <list>) => <list>

Returns its argument with all duplicate elements removed. The first instance of each element is preserved.

(DELQ <element> <list>) => <list>
(DELQ! <element> <list>) => <list>
(DELETE <predicate> <list>) => <list>

All three of these return <list> with some elements removed. DELQ removes all elements EQ? to <element>. DELQ! does the same and may reuse the storage of the list argument. DELETE removes all elements for which <predicate> is true.

(REVERSE! <list>) => <list>

Destructively reverses <list>.

(SORT-LIST <list> <a<b-procedure>) => <list>
(SORT-LIST! <list> <a<b-procedure>) => <list>

Returns a sorted copy of <list>. The sorting algorithm is stable. (SORT-LIST '(6 5 1 3 2 4) <) => '(1 2 3 4 5 6)

Additional syntax

(DESTRUCTURE ((<pattern> <init>) ...) <body> ...) *SYNTAX*

The <init>s are evaluated and their values are dissasembled according to the corresponding patterns, with identifiers in the patterns being bound to fresh locations holding the corresponding part, and the body is evaluated in the extended environment. Patterns may be any of the following:

#f

Discard the corresponding part.

<identifier>

Bind the <indentifier> to the part.

(<pattern> ...)

The part must be a list at least as long as the pattern.

(<pattern1> ... . <patternN>)

The same thing, except that the final CDR of the part is dissasembled according to <patternN>.

#(<pattern> ...)

The part must be a vector at least as long as the pattern.

(RECEIVE <identifiers> <exp> <body> ...) *SYNTAX*

=> (CALL-WITH-VALUES (LAMBDA () <exp>) (LAMBDA <identifiers> <body> ...)) Bind <identifiers> to the values returned by <exp>, and evaluate the body in the resulting environment.

Printing and related procedures

(CONCATENATE-SYMBOL . <components>)

Returns the symbol whose name is produced by concatenating the DISPLAYed representations of <components>. (CONCATENATE-SYMBOL 'abc "-" 4) => 'abc-4

(FORMAT <port-spec> <format-string> . <arguments>) => <string> or <undefined>

Prints the arguments to the port as directed by the string. <port-spec> should be either:

An output port.

The output is written directly to the port. The result of the call to FORMAT is undefined.

#T.

The output is written to the current output port. The result of the call to FORMAT is undefined.

#F.

The output is written to a string, which is then the value returned from the call to FORMAT.

Characters in <format-string> which are not preceded by a ~ are written directly to the output. Characters preceded by a ~ have the following meaning (case is irrelevant; ~a and ~A have the same meaning):

~~

prints a single ~

~A

prints the next argument using DISPLAY

~D

prints the next argument as a decimal number

~S

prints the next argument using WRITE

~%

prints a newline character

~&

prints a NEWLINE character if the previous printed character was not one (this is implemented using FRESH-LINE)

~?

performs a recursive call to FORMAT using the next two arguments as the string and the list of arguments

(ERROR <format-string> . <format-arguments>)
(BREAKPOINT <format-string> . <format-arguments>)

Signals an error or breakpoint condition, passing it the result of applying FORMAT to the arguments.

(P <thing>)
(P <thing> <output-port>)
(PRETTY-PRINT <thing> <output-port> <position>)

Pretty-print <thing>. The current output port is used if no port is specified. <position> is the starting offset. <thing> will be pretty-printed to the right of this column.

Ownership, Maintenance and Disclaimers

Scheme48 Manual Top Page

Envision Manual Top Page

Last modified