guile-procedures.txt

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

   accessor-method-slot-definition

 - Scheme Procedure: accessor-method-slot-definition obj
     Return the slot definition of the accessor OBJ.

   %tag-body

 - Scheme Procedure: %tag-body body
     Internal GOOPS magic--don't use this function!

   make-unbound

 - Scheme Procedure: make-unbound
     Return the unbound value.

   unbound?

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

   assert-bound

 - Scheme Procedure: assert-bound value obj
     Return VALUE if it is bound, and invoke the SLOT-UNBOUND method of
     OBJ if it is not.

   @assert-bound-ref

 - Scheme Procedure: @assert-bound-ref obj index
     Like `assert-bound', but use INDEX for accessing the value from
     OBJ.

   %fast-slot-ref

 - Scheme Procedure: %fast-slot-ref obj index
     Return the slot value with index INDEX from OBJ.

   %fast-slot-set!

 - Scheme Procedure: %fast-slot-set! obj index value
     Set the slot with index INDEX in OBJ to VALUE.

   slot-ref-using-class

 - Scheme Procedure: slot-ref-using-class class obj slot_name

   slot-set-using-class!

 - Scheme Procedure: slot-set-using-class! class obj slot_name value

   slot-bound-using-class?

 - Scheme Procedure: slot-bound-using-class? class obj slot_name

   slot-exists-using-class?

 - Scheme Procedure: slot-exists-using-class? class obj slot_name

   slot-ref

 - Scheme Procedure: slot-ref obj slot_name
     Return the value from OBJ's slot with the name SLOT_NAME.

   slot-set!

 - Scheme Procedure: slot-set! obj slot_name value
     Set the slot named SLOT_NAME of OBJ to VALUE.

   slot-bound?

 - Scheme Procedure: slot-bound? obj slot_name
     Return `#t' if the slot named SLOT_NAME of OBJ is bound.

   slot-exists?

 - Scheme Procedure: slot-exists? obj slot_name
     Return `#t' if OBJ has a slot named SLOT_NAME.

   %allocate-instance

 - Scheme Procedure: %allocate-instance class initargs
     Create a new instance of class CLASS and initialize it from the
     arguments INITARGS.

   %set-object-setter!

 - Scheme Procedure: %set-object-setter! obj setter

   %modify-instance

 - Scheme Procedure: %modify-instance old new

   %modify-class

 - Scheme Procedure: %modify-class old new

   %invalidate-class

 - Scheme Procedure: %invalidate-class class

   %invalidate-method-cache!

 - Scheme Procedure: %invalidate-method-cache! gf

   generic-capability?

 - Scheme Procedure: generic-capability? proc

   enable-primitive-generic!

 - Scheme Procedure: enable-primitive-generic! . subrs

   primitive-generic-generic

 - Scheme Procedure: primitive-generic-generic subr

   make

 - Scheme Procedure: make . args
     Make a new object.  ARGS must contain the class and all necessary
     initialization information.

   find-method

 - Scheme Procedure: find-method . l

   %method-more-specific?

 - Scheme Procedure: %method-more-specific? m1 m2 targs

   %goops-loaded

 - Scheme Procedure: %goops-loaded
     Announce that GOOPS is loaded and perform initialization on the C
     level which depends on the loaded GOOPS modules.

   make-guardian

 - Scheme Procedure: make-guardian [greedy_p]
     Create a new guardian.  A guardian protects a set of objects from
     garbage collection, allowing a program to apply cleanup or other
     actions.

     `make-guardian' returns a procedure representing the guardian.
     Calling the guardian procedure with an argument adds the argument
     to the guardian's set of protected objects.  Calling the guardian
     procedure without an argument returns one of the protected objects
     which are ready for garbage collection, or `#f' if no such object
     is available.  Objects which are returned in this way are removed
     from the guardian.

     `make-guardian' takes one optional argument that says whether the
     new guardian should be greedy or sharing.  If there is any chance
     that any object protected by the guardian may be resurrected, then
     you should make the guardian greedy (this is the default).

     See R. Kent Dybvig, Carl Bruggeman, and David Eby (1993)
     "Guardians in a Generation-Based Garbage Collector".  ACM SIGPLAN
     Conference on Programming Language Design and Implementation, June
     1993.

     (the semantics are slightly different at this point, but the paper
     still (mostly) accurately describes the interface).

   guardian-destroyed?

 - Scheme Procedure: guardian-destroyed? guardian
     Return `#t' if GUARDIAN has been destroyed, otherwise `#f'.

   guardian-greedy?

 - Scheme Procedure: guardian-greedy? guardian
     Return `#t' if GUARDIAN is a greedy guardian, otherwise `#f'.

   destroy-guardian!

 - Scheme Procedure: destroy-guardian! guardian
     Destroys GUARDIAN, by making it impossible to put any more objects
     in it or get any objects from it.  It also unguards any objects
     guarded by GUARDIAN.

   hashq

 - Scheme Procedure: hashq key size
     Determine a hash value for KEY that is suitable for lookups in a
     hashtable of size SIZE, where `eq?' is used as the equality
     predicate.  The function returns an integer in the range 0 to SIZE
     - 1.  Note that `hashq' may use internal addresses.  Thus two
     calls to hashq where the keys are `eq?' are not guaranteed to
     deliver the same value if the key object gets garbage collected in
     between.  This can happen, for example with symbols: `(hashq 'foo
     n) (gc) (hashq 'foo n)' may produce two different values, since
     `foo' will be garbage collected.

   hashv

 - Scheme Procedure: hashv key size
     Determine a hash value for KEY that is suitable for lookups in a
     hashtable of size SIZE, where `eqv?' is used as the equality
     predicate.  The function returns an integer in the range 0 to SIZE
     - 1.  Note that `(hashv key)' may use internal addresses.  Thus
     two calls to hashv where the keys are `eqv?' are not guaranteed to
     deliver the same value if the key object gets garbage collected in
     between.  This can happen, for example with symbols: `(hashv 'foo
     n) (gc) (hashv 'foo n)' may produce two different values, since
     `foo' will be garbage collected.

   hash

 - Scheme Procedure: hash key size
     Determine a hash value for KEY that is suitable for lookups in a
     hashtable of size SIZE, where `equal?' is used as the equality
     predicate.  The function returns an integer in the range 0 to SIZE
     - 1.

   hashq-get-handle

 - Scheme Procedure: hashq-get-handle table key
     This procedure returns the `(key . value)' pair from the hash
     table TABLE.  If TABLE does not hold an associated value for KEY,
     `#f' is returned.  Uses `eq?' for equality testing.

   hashq-create-handle!

 - Scheme Procedure: hashq-create-handle! table key init
     This function looks up KEY in TABLE and returns its handle.  If
     KEY is not already present, a new handle is created which
     associates KEY with INIT.

   hashq-ref

 - Scheme Procedure: hashq-ref table key [dflt]
     Look up KEY in the hash table TABLE, and return the value (if any)
     associated with it.  If KEY is not found, return DEFAULT (or `#f'
     if no DEFAULT argument is supplied).  Uses `eq?' for equality
     testing.

   hashq-set!

 - Scheme Procedure: hashq-set! table key val
     Find the entry in TABLE associated with KEY, and store VALUE
     there. Uses `eq?' for equality testing.

   hashq-remove!

 - Scheme Procedure: hashq-remove! table key
     Remove KEY (and any value associated with it) from TABLE.  Uses
     `eq?' for equality tests.

   hashv-get-handle

 - Scheme Procedure: hashv-get-handle table key
     This procedure returns the `(key . value)' pair from the hash
     table TABLE.  If TABLE does not hold an associated value for KEY,
     `#f' is returned.  Uses `eqv?' for equality testing.

   hashv-create-handle!

 - Scheme Procedure: hashv-create-handle! table key init
     This function looks up KEY in TABLE and returns its handle.  If
     KEY is not already present, a new handle is created which
     associates KEY with INIT.

   hashv-ref

 - Scheme Procedure: hashv-ref table key [dflt]
     Look up KEY in the hash table TABLE, and return the value (if any)
     associated with it.  If KEY is not found, return DEFAULT (or `#f'
     if no DEFAULT argument is supplied).  Uses `eqv?' for equality
     testing.

   hashv-set!

 - Scheme Procedure: hashv-set! table key val
     Find the entry in TABLE associated with KEY, and store VALUE
     there. Uses `eqv?' for equality testing.

   hashv-remove!

 - Scheme Procedure: hashv-remove! table key
     Remove KEY (and any value associated with it) from TABLE.  Uses
     `eqv?' for equality tests.

   hash-get-handle

 - Scheme Procedure: hash-get-handle table key
     This procedure returns the `(key . value)' pair from the hash
     table TABLE.  If TABLE does not hold an associated value for KEY,
     `#f' is returned.  Uses `equal?' for equality testing.

   hash-create-handle!

 - Scheme Procedure: hash-create-handle! table key init
     This function looks up KEY in TABLE and returns its handle.  If
     KEY is not already present, a new handle is created which
     associates KEY with INIT.

   hash-ref

 - Scheme Procedure: hash-ref table key [dflt]
     Look up KEY in the hash table TABLE, and return the value (if any)
     associated with it.  If KEY is not found, return DEFAULT (or `#f'
     if no DEFAULT argument is supplied).  Uses `equal?' for equality
     testing.

   hash-set!

 - Scheme Procedure: hash-set! table key val
     Find the entry in TABLE associated with KEY, and store VALUE
     there. Uses `equal?' for equality testing.

   hash-remove!

 - Scheme Procedure: hash-remove! table key
     Remove KEY (and any value associated with it) from TABLE.  Uses
     `equal?' for equality tests.

   hashx-get-handle

 - Scheme Procedure: hashx-get-handle hash assoc table key
     This behaves the same way as the corresponding `-get-handle'
     function, but uses HASH as a hash function and ASSOC to compare
     keys.  `hash' must be a function that takes two arguments, a key
     to be hashed and a table size.  `assoc' must be an associator
     function, like `assoc', `assq' or `assv'.

   hashx-create-handle!

 - Scheme Procedure: hashx-create-handle! hash assoc table key init
     This behaves the same way as the corresponding `-create-handle'
     function, but uses HASH as a hash function and ASSOC to compare
     keys.  `hash' must be a function that takes two arguments, a key
     to be hashed and a table size.  `assoc' must be an associator
     function, like `assoc', `assq' or `assv'.

   hashx-ref

 - Scheme Procedure: hashx-ref hash assoc table key [dflt]
     This behaves the same way as the corresponding `ref' function, but
     uses HASH as a hash function and ASSOC to compare keys.  `hash'
     must be a function that takes two arguments, a key to be hashed
     and a table size.  `assoc' must be an associator function, like
     `assoc', `assq' or `assv'.

     By way of illustration, `hashq-ref table key' is equivalent to
     `hashx-ref hashq assq table key'.

   hashx-set!

 - Scheme Procedure: hashx-set! hash assoc table key val
     This behaves the same way as the corresponding `set!' function,
     but uses HASH as a hash function and ASSOC to compare keys.
     `hash' must be a function that takes two arguments, a key to be
     hashed and a table size.  `assoc' must be an associator function,
     like `assoc', `assq' or `assv'.

     By way of illustration, `hashq-set! table key' is equivalent to
     `hashx-set!  hashq assq table key'.

   hash-fold

 - Scheme Procedure: hash-fold proc init table
     An iterator over hash-table elements.  Accumulates and returns a
     result by applying PROC successively.  The arguments to PROC are
     "(key value prior-result)" where key and value are successive
     pairs from the hash table TABLE, and prior-result is either INIT
     (for the first application of PROC) or the return value of the
     previous application of PROC.  For example, `(hash-fold acons '()
     tab)' will convert a hash table into an a-list of key-value pairs.

   make-hook

 - Scheme Procedure: make-hook [n_args]
     Create a hook for storing procedure of arity N_ARGS.  N_ARGS
     defaults to zero.  The returned value is a hook object to be used
     with the other hook procedures.

   hook?

 - Scheme Procedure: hook? x
     Return `#t' if X is a hook, `#f' otherwise.

   hook-empty?

 - Scheme Procedure: hook-empty? hook
     Return `#t' if HOOK is an empty hook, `#f' otherwise.

   add-hook!

 - Scheme Procedure: add-hook! hook proc [append_p]
     Add the procedure PROC to the hook HOOK. The procedure is added to
     the end if APPEND_P is true, otherwise it is added to the front.