guile-procedures.txt

MSYS在windows下模拟了一个类unix的终端

This is guile-procedures.txt, produced by makeinfo version 4.0 from
guile-procedures.texi.

   acons

 - Scheme Procedure: acons key value alist
     Add a new key-value pair to ALIST.  A new pair is created whose
     car is KEY and whose cdr is VALUE, and the pair is consed onto
     ALIST, and the new list is returned.  This function is _not_
     destructive; ALIST is not modified.

   sloppy-assq

 - Scheme Procedure: sloppy-assq key alist
     Behaves like `assq' but does not do any error checking.
     Recommended only for use in Guile internals.

   sloppy-assv

 - Scheme Procedure: sloppy-assv key alist
     Behaves like `assv' but does not do any error checking.
     Recommended only for use in Guile internals.

   sloppy-assoc

 - Scheme Procedure: sloppy-assoc key alist
     Behaves like `assoc' but does not do any error checking.
     Recommended only for use in Guile internals.

   assq

 - Scheme Procedure: assq key alist
 - Scheme Procedure: assv key alist
 - Scheme Procedure: assoc key alist
     Fetch the entry in ALIST that is associated with KEY.  To decide
     whether the argument KEY matches a particular entry in ALIST,
     `assq' compares keys with `eq?', `assv' uses `eqv?' and `assoc'
     uses `equal?'.  If KEY cannot be found in ALIST (according to
     whichever equality predicate is in use), then return `#f'.  These
     functions return the entire alist entry found (i.e. both the key
     and the value).

   assv

 - Scheme Procedure: assv key alist
     Behaves like `assq' but uses `eqv?' for key comparison.

   assoc

 - Scheme Procedure: assoc key alist
     Behaves like `assq' but uses `equal?' for key comparison.

   assq-ref

 - Scheme Procedure: assq-ref alist key
 - Scheme Procedure: assv-ref alist key
 - Scheme Procedure: assoc-ref alist key
     Like `assq', `assv' and `assoc', except that only the value
     associated with KEY in ALIST is returned.  These functions are
     equivalent to

          (let ((ent (ASSOCIATOR KEY ALIST)))
            (and ent (cdr ent)))

     where ASSOCIATOR is one of `assq', `assv' or `assoc'.

   assv-ref

 - Scheme Procedure: assv-ref alist key
     Behaves like `assq-ref' but uses `eqv?' for key comparison.

   assoc-ref

 - Scheme Procedure: assoc-ref alist key
     Behaves like `assq-ref' but uses `equal?' for key comparison.

   assq-set!

 - Scheme Procedure: assq-set! alist key val
 - Scheme Procedure: assv-set! alist key value
 - Scheme Procedure: assoc-set! alist key value
     Reassociate KEY in ALIST with VALUE: find any existing ALIST entry
     for KEY and associate it with the new VALUE.  If ALIST does not
     contain an entry for KEY, add a new one.  Return the (possibly
     new) alist.

     These functions do not attempt to verify the structure of ALIST,
     and so may cause unusual results if passed an object that is not an
     association list.

   assv-set!

 - Scheme Procedure: assv-set! alist key val
     Behaves like `assq-set!' but uses `eqv?' for key comparison.

   assoc-set!

 - Scheme Procedure: assoc-set! alist key val
     Behaves like `assq-set!' but uses `equal?' for key comparison.

   assq-remove!

 - Scheme Procedure: assq-remove! alist key
 - Scheme Procedure: assv-remove! alist key
 - Scheme Procedure: assoc-remove! alist key
     Delete the first entry in ALIST associated with KEY, and return
     the resulting alist.

   assv-remove!

 - Scheme Procedure: assv-remove! alist key
     Behaves like `assq-remove!' but uses `eqv?' for key comparison.

   assoc-remove!

 - Scheme Procedure: assoc-remove! alist key
     Behaves like `assq-remove!' but uses `equal?' for key comparison.

   make-arbiter

 - Scheme Procedure: make-arbiter name
     Return an object of type arbiter and name NAME. Its state is
     initially unlocked.  Arbiters are a way to achieve process
     synchronization.

   try-arbiter

 - Scheme Procedure: try-arbiter arb
     Return `#t' and lock the arbiter ARB if the arbiter was unlocked.
     Otherwise, return `#f'.

   release-arbiter

 - Scheme Procedure: release-arbiter arb
     Return `#t' and unlock the arbiter ARB if the arbiter was locked.
     Otherwise, return `#f'.

   async

 - Scheme Procedure: async thunk
     Create a new async for the procedure THUNK.

   system-async

 - Scheme Procedure: system-async thunk
     Create a new async for the procedure THUNK.  Also add it to the
     system's list of active async objects.

   async-mark

 - Scheme Procedure: async-mark a
     Mark the async A for future execution.

   system-async-mark

 - Scheme Procedure: system-async-mark a
     Mark the async A for future execution.

   run-asyncs

 - Scheme Procedure: run-asyncs list_of_a
     Execute all thunks from the asyncs of the list LIST_OF_A.

   noop

 - Scheme Procedure: noop . args
     Do nothing.  When called without arguments, return `#f', otherwise
     return the first argument.

   unmask-signals

 - Scheme Procedure: unmask-signals
     Unmask signals. The returned value is not specified.

   mask-signals

 - Scheme Procedure: mask-signals
     Mask signals. The returned value is not specified.

   display-error

 - Scheme Procedure: display-error stack port subr message args rest
     Display an error message to the output port PORT.  STACK is the
     saved stack for the error, SUBR is the name of the procedure in
     which the error occurred and MESSAGE is the actual error message,
     which may contain formatting instructions. These will format the
     arguments in the list ARGS accordingly.  REST is currently ignored.

   display-application

 - Scheme Procedure: display-application frame [port [indent]]
     Display a procedure application FRAME to the output port PORT.
     INDENT specifies the indentation of the output.

   display-backtrace

 - Scheme Procedure: display-backtrace stack port [first [depth]]
     Display a backtrace to the output port PORT. STACK is the stack to
     take the backtrace from, FIRST specifies where in the stack to
     start and DEPTH how much frames to display. Both FIRST and DEPTH
     can be `#f', which means that default values will be used.

   backtrace

 - Scheme Procedure: backtrace
     Display a backtrace of the stack saved by the last error to the
     current output port.

   not

 - Scheme Procedure: not x
     Return `#t' iff X is `#f', else return `#f'.

   boolean?

 - Scheme Procedure: boolean? obj
     Return `#t' iff OBJ is either `#t' or `#f'.

   char?

 - Scheme Procedure: char? x
     Return `#t' iff X is a character, else `#f'.

   char=?

 - Scheme Procedure: char=? x y
     Return `#t' iff X is the same character as Y, else `#f'.

   char<?

 - Scheme Procedure: char<? x y
     Return `#t' iff X is less than Y in the ASCII sequence, else `#f'.

   char<=?

 - Scheme Procedure: char<=? x y
     Return `#t' iff X is less than or equal to Y in the ASCII
     sequence, else `#f'.

   char>?

 - Scheme Procedure: char>? x y
     Return `#t' iff X is greater than Y in the ASCII sequence, else
     `#f'.

   char>=?

 - Scheme Procedure: char>=? x y
     Return `#t' iff X is greater than or equal to Y in the ASCII
     sequence, else `#f'.

   char-ci=?

 - Scheme Procedure: char-ci=? x y
     Return `#t' iff X is the same character as Y ignoring case, else
     `#f'.

   char-ci<?

 - Scheme Procedure: char-ci<? x y
     Return `#t' iff X is less than Y in the ASCII sequence ignoring
     case, else `#f'.

   char-ci<=?

 - Scheme Procedure: char-ci<=? x y
     Return `#t' iff X is less than or equal to Y in the ASCII sequence
     ignoring case, else `#f'.

   char-ci>?

 - Scheme Procedure: char-ci>? x y
     Return `#t' iff X is greater than Y in the ASCII sequence ignoring
     case, else `#f'.

   char-ci>=?

 - Scheme Procedure: char-ci>=? x y
     Return `#t' iff X is greater than or equal to Y in the ASCII
     sequence ignoring case, else `#f'.

   char-alphabetic?

 - Scheme Procedure: char-alphabetic? chr
     Return `#t' iff CHR is alphabetic, else `#f'.  Alphabetic means
     the same thing as the isalpha C library function.

   char-numeric?

 - Scheme Procedure: char-numeric? chr
     Return `#t' iff CHR is numeric, else `#f'.  Numeric means the same
     thing as the isdigit C library function.

   char-whitespace?

 - Scheme Procedure: char-whitespace? chr
     Return `#t' iff CHR is whitespace, else `#f'.  Whitespace means
     the same thing as the isspace C library function.

   char-upper-case?

 - Scheme Procedure: char-upper-case? chr
     Return `#t' iff CHR is uppercase, else `#f'.  Uppercase means the
     same thing as the isupper C library function.

   char-lower-case?

 - Scheme Procedure: char-lower-case? chr
     Return `#t' iff CHR is lowercase, else `#f'.  Lowercase means the
     same thing as the islower C library function.

   char-is-both?

 - Scheme Procedure: char-is-both? chr
     Return `#t' iff CHR is either uppercase or lowercase, else `#f'.
     Uppercase and lowercase are as defined by the isupper and islower
     C library functions.

   char->integer

 - Scheme Procedure: char->integer chr
     Return the number corresponding to ordinal position of CHR in the
     ASCII sequence.

   integer->char

 - Scheme Procedure: integer->char n
     Return the character at position N in the ASCII sequence.

   char-upcase

 - Scheme Procedure: char-upcase chr
     Return the uppercase character version of CHR.

   char-downcase

 - Scheme Procedure: char-downcase chr
     Return the lowercase character version of CHR.

   debug-options-interface

 - Scheme Procedure: debug-options-interface [setting]
     Option interface for the debug options. Instead of using this
     procedure directly, use the procedures `debug-enable',
     `debug-disable', `debug-set!' and `debug-options'.

   with-traps

 - Scheme Procedure: with-traps thunk
     Call THUNK with traps enabled.

   memoized?

 - Scheme Procedure: memoized? obj
     Return `#t' if OBJ is memoized.

   unmemoize

 - Scheme Procedure: unmemoize m
     Unmemoize the memoized expression M,

   memoized-environment

 - Scheme Procedure: memoized-environment m
     Return the environment of the memoized expression M.

   procedure-name

 - Scheme Procedure: procedure-name proc
     Return the name of the procedure PROC

   procedure-source

 - Scheme Procedure: procedure-source proc
     Return the source of the procedure PROC.

   procedure-environment

 - Scheme Procedure: procedure-environment proc
     Return the environment of the procedure PROC.

   local-eval

 - Scheme Procedure: local-eval exp [env]
     Evaluate EXP in its environment.  If ENV is supplied, it is the
     environment in which to evaluate EXP.  Otherwise, EXP must be a
     memoized code object (in which case, its environment is implicit).

   debug-object?

 - Scheme Procedure: debug-object? obj
     Return `#t' if OBJ is a debug object.