 -- primitive: environment? obj
     Return #t if OBJ is an environment, or #f otherwise.

 -- primitive: environment-bound? env sym
     Return #t if SYM is bound in ENV, or #f otherwise.

 -- primitive: environment-ref env sym
     Return the value of the location bound to SYM in ENV. If SYM is unbound in ENV, signal an environment:unbound error.

 -- primitive: environment-fold env proc init
     Iterate over all the bindings in ENV, accumulating some value. For each binding in ENV, apply PROC to the symbol bound, its value, and the result from the previous application of PROC. Use INIT as PROC's third argument the first time PROC is applied. If ENV contains no bindings, this function simply returns INIT. If ENV binds the symbol sym1 to the value val1, sym2 to val2, and so on, then this procedure computes:

            (proc sym1 val1
                  (proc sym2 val2
                        ...
                        (proc symn valn
                              init)))

     Each binding in ENV will be processed exactly once. environment-fold makes no guarantees about the order in which the bindings are processed. Here is a function which, given an environment, constructs an association list representing that environment's bindings, using environment-fold:

            (define (environment->alist env)
              (environment-fold env
                                (lambda (sym val tail)
                                  (cons (cons sym val) tail))
                                '()))

 -- primitive: environment-define env sym val
     Bind SYM to a new location containing VAL in ENV. If SYM is already bound to another location in ENV and the binding is mutable, that binding is replaced.  The new binding and location are both mutable. The return value is unspecified. If SYM is already bound in ENV, and the binding is immutable, signal an environment:immutable-binding error.

 -- primitive: environment-undefine env sym
     Remove any binding for SYM from ENV. If SYM is unbound in ENV, do nothing.  The return value is unspecified. If SYM is already bound in ENV, and the binding is immutable, signal an environment:immutable-binding error.

 -- primitive: environment-set! env sym val
     If ENV binds SYM to some location, change that location's value to VAL.  The return value is unspecified. If SYM is not bound in ENV, signal an environment:unbound error.  If ENV binds SYM to an immutable location, signal an environment:immutable-location error.

 -- primitive: environment-cell env sym for_write
     Return the value cell which ENV binds to SYM, or #f if the binding does not live in a value cell. The argument FOR-WRITE indicates whether the caller intends to modify the variable's value by mutating the value cell.  If the variable is immutable, then environment-cell signals an environment:immutable-location error. If SYM is unbound in ENV, signal an environment:unbound error. If you use this function, you should consider using environment-observe, to be notified when SYM gets re-bound to a new value cell, or becomes undefined.

 -- primitive: environment-observe env proc
     Whenever ENV's bindings change, apply PROC to ENV. This function returns an object, token, which you can pass to environment-unobserve to remove PROC from the set of procedures observing ENV.  The type and value of token is unspecified.

 -- primitive: environment-observe-weak env proc
     This function is the same as environment-observe, except that the reference ENV retains to PROC is a weak reference. This means that, if there are no other live, non-weak references to PROC, it will be garbage-collected, and dropped from ENV's list of observing procedures.

 -- primitive: environment-unobserve token
     Cancel the observation request which returned the value TOKEN.  The return value is unspecified. If a call (environment-observe env proc) returns TOKEN, then the call (environment-unobserve token) will cause PROC to no longer be called when ENV's bindings change.

 -- primitive: make-leaf-environment
     Create a new leaf environment, containing no bindings. All bindings and locations created in the new environment will be mutable.

 -- primitive: leaf-environment? object
     Return #t if object is a leaf environment, or #f otherwise.

 -- primitive: make-eval-environment local imported
     Return a new environment object eval whose bindings are the union of the bindings in the environments LOCAL and IMPORTED, with bindings from LOCAL taking precedence. Definitions made in eval are placed in LOCAL. Applying environment-define or environment-undefine to eval has the same effect as applying the procedure to LOCAL. Note that eval incorporates LOCAL and IMPORTED by reference: If, after creating eval, the program changes the bindings of LOCAL or IMPORTED, those changes will be visible in eval. Since most Scheme evaluation takes place in eval environments, they transparently cache the bindings received from LOCAL and IMPORTED. Thus, the first time the program looks up a symbol in eval, eval may make calls to LOCAL or IMPORTED to find their bindings, but subsequent references to that symbol will be as fast as references to bindings in finite environments. In typical use, LOCAL will be a finite environment, and IMPORTED will be an import environment

 -- primitive: eval-environment? object
     Return #t if object is an eval environment, or #f otherwise.

 -- primitive: eval-environment-local env
     Return the local environment of eval environment ENV.

 -- primitive: eval-environment-set-local! env local
     Change ENV's local environment to LOCAL.

 -- primitive: eval-environment-imported env
     Return the imported environment of eval environment ENV.

 -- primitive: eval-environment-set-imported! env imported
     Change ENV's imported environment to IMPORTED.

 -- primitive: make-import-environment imports conflict_proc
     Return a new environment IMP whose bindings are the union of the bindings from the environments in IMPORTS; IMPORTS must be a list of environments. That is, IMP binds a symbol to a location when some element of IMPORTS does. If two different elements of IMPORTS have a binding for the same symbol, the CONFLICT-PROC is called with the following parameters:  the import environment, the symbol and the list of the imported environments that bind the symbol. If the CONFLICT-PROC returns an environment ENV, the conflict is considered as resolved and the binding from ENV is used.  If the CONFLICT-PROC returns some non-environment object, the conflict is considered unresolved and the symbol is treated as unspecified in the import environment. The checking for conflicts may be performed lazily, i. e. at the moment when a value or binding for a certain symbol is requested instead of the moment when the environment is created or the bindings of the imports change. All bindings in IMP are immutable. If you apply environment-define or environment-undefine to IMP, Guile will signal an environment:immutable-binding error. However, notice that the set of bindings in IMP may still change, if one of its imported environments changes.

 -- primitive: import-environment? object
     Return #t if object is an import environment, or #f otherwise.

 -- primitive: import-environment-imports env
     Return the list of environments imported by the import environment ENV.

 -- primitive: import-environment-set-imports! env imports
     Change ENV's list of imported environments to IMPORTS, and check for conflicts.

 -- primitive: make-export-environment private signature
     Return a new environment EXP containing only those bindings in private whose symbols are present in SIGNATURE. The PRIVATE argument must be an environment.

     The environment EXP binds symbol to location when ENV does, and symbol is exported by SIGNATURE.

     SIGNATURE is a list specifying which of the bindings in PRIVATE should be visible in EXP. Each element of SIGNATURE should be a list of the form: (symbol attribute ...) where each attribute is one of the following:

     the symbol mutable-location
          EXP should treat the location bound to symbol as mutable. That is, EXP will pass calls to environment-set! or environment-cell directly through to private.

     the symbol immutable-location
          EXP should treat the location bound to symbol as immutable. If the program applies environment-set! to EXP and symbol, or calls environment-cell to obtain a writable value cell, environment-set! will signal an environment:immutable-location error. Note that, even if an export environment treats a location as immutable, the underlying environment may treat it as mutable, so its value may change.

     It is an error for an element of signature to specify both mutable-location and immutable-location. If neither is specified, immutable-location is assumed.

     As a special case, if an element of signature is a lone symbol SYM, it is equivalent to an element of the form (sym).

     All bindings in EXP are immutable. If you apply environment-define or environment-undefine to EXP, Guile will signal an environment:immutable-binding error. However, notice that the set of bindings in EXP may still change, if the bindings in private change.

 -- primitive: export-environment? object
     Return #t if object is an export environment, or #f otherwise.

 -- primitive: export-environment-private env
     Return the private environment of export environment ENV.

 -- primitive: export-environment-set-private! env private
     Change the private environment of export environment ENV.

 -- primitive: export-environment-signature env
     Return the signature of export environment ENV.

 -- primitive: export-environment-set-signature! env signature
     Change the signature of export environment ENV.

 -- primitive: %compute-slots class
     Return a list consisting of the names of all slots belonging to class CLASS, i. e. the slots of CLASS and of all of its superclasses.

 -- primitive: get-keyword key l default_value
     Determine an associated value for the keyword KEY from the list L.  The list L has to consist of an even number of elements, where, starting with the first, every second element is a keyword, followed by its associated value. If L does not hold a value for KEY, the value DEFAULT_VALUE is returned.

 -- primitive: slot-ref-using-class class obj slot_name

 -- primitive: slot-set-using-class! class obj slot_name value

 -- primitive: class-of x
     Return the class of X.

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

 -- primitive: %method-more-specific? m1 m2 targs

 -- primitive: find-method . l

 -- primitive: primitive-generic-generic subr

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

 -- primitive: generic-capability? proc

 -- primitive: %invalidate-method-cache! gf

 -- primitive: %invalidate-class class

 -- primitive: %modify-class old new

 -- primitive: %modify-instance old new

 -- primitive: %set-object-setter! obj setter

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

 -- primitive: slot-exists? obj slot_name
     Return #t if OBJ has a slot named SLOT_NAME.

 -- primitive: slot-bound? obj slot_name
     Return #t if the slot named SLOT_NAME of OBJ is bound.

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

 -- primitive: slot-exists-using-class? class obj slot_name

 -- primitive: slot-bound-using-class? class obj slot_name

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

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

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

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

 -- primitive: unbound? obj
     Return #t if OBJ is unbound.

 -- primitive: make-unbound
     Return the unbound value.

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

 -- primitive: method-procedure obj
     Return the procedure of the method OBJ.

 -- primitive: method-specializers obj
     Return specializers of the method OBJ.

 -- primitive: method-generic-function obj
     Return the generic function fot the method OBJ.

 -- primitive: generic-function-methods obj
     Return the methods of the generic function OBJ.

 -- primitive: generic-function-name obj
     Return the name of the generic function OBJ.

 -- primitive: class-environment obj
     Return the environment of the class OBJ.

 -- primitive: class-slots obj
     Return the slot list of the class OBJ.

 -- primitive: class-precedence-list obj
     Return the class precedence list of the class OBJ.

 -- primitive: class-direct-methods obj
     Return the direct methods of the class OBJ

 -- primitive: class-direct-subclasses obj
     Return the direct subclasses of the class OBJ.

 -- primitive: class-direct-slots obj
     Return the direct slots of the class OBJ.

 -- primitive: class-direct-supers obj
     Return the direct superclasses of the class OBJ.

 -- primitive: class-name obj
     Return the class name of OBJ.

 -- primitive: instance? obj
     Return #t if OBJ is an instance.

 -- primitive: %inherit-magic! class dsupers

 -- primitive: %prep-layout! class

 -- primitive: %initialize-object obj initargs
     Initialize the object OBJ with the given arguments INITARGS.

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

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

 -- primitive: builtin-bindings
     Create and return a copy of the global symbol table, removing all unbound symbols.

 -- primitive: object->string obj [printer]
     Return a Scheme string obtained by printing OBJ. Printing function can be specified by the optional second argument PRINTER (default: write).

 -- primitive: gethostname
     Return the host name of the current processor.

 -- primitive: sethostname name
     Set the host name of the current processor to NAME. May only be used by the superuser.  The return value is not specified.

 -- primitive: flock file operation
     Apply or remove an advisory lock on an open file. OPERATION specifies the action to be done:

     LOCK_SH
          Shared lock.  More than one process may hold a shared lock for a given file at a given time.

     LOCK_EX
          Exclusive lock.  Only one process may hold an exclusive lock for a given file at a given time.

     LOCK_UN
          Unlock the file.

     LOCK_NB
          Don't block when locking.  May be specified by bitwise OR'ing it to one of the other operations.

     The return value is not specified. FILE may be an open file descriptor or an open file descriptior port.

 -- primitive: getpass prompt
     Display PROMPT to the standard error output and read a password from /dev/tty.  If this file is not accessible, it reads from standard input.  The password may be up to 127 characters in length.  Additional characters and the terminating newline character are discarded.  While reading the password, echoing and the generation of signals by special characters is disabled.

 -- primitive: setpriority which who prio
     Set the scheduling priority of the process, process group or user, as indicated by WHICH and WHO. WHICH is one of the variables PRIO_PROCESS, PRIO_PGRP or PRIO_USER, and WHO is interpreted relative to WHICH (a process identifier for PRIO_PROCESS, process group identifier for PRIO_PGRP, and a user identifier for PRIO_USER.  A zero value of WHO denotes the current process, process group, or user. PRIO is a value in the range -20 and 20, the default priority is 0; lower priorities cause more favorable scheduling.  Sets the priority of all of the specified processes.  Only the super-user may lower priorities. The return value is not specified.

 -- primitive: getpriority which who
     Return the scheduling priority of the process, process group or user, as indicated by WHICH and WHO. WHICH is one of the variables PRIO_PROCESS, PRIO_PGRP or PRIO_USER, and WHO is interpreted relative to WHICH (a process identifier for PRIO_PROCESS, process group identifier for PRIO_PGRP, and a user identifier for PRIO_USER.  A zero value of WHO denotes the current process, process group, or user.  Return the highest priority (lowest numerical value) of any of the specified processes.

 -- primitive: cuserid
     Return a string containing a user name associated with the effective user id of the process.  Return #f if this information cannot be obtained.

 -- primitive: getlogin
     Return a string containing the name of the user logged in on the controlling terminal of the process, or #f if this information cannot be obtained.

 -- primitive: chroot path
     Change the root directory to that specified in PATH. This directory will be used for path names beginning with /.  The root directory is inherited by all children of the current process.  Only the superuser may change the root directory.

 -- primitive: crypt key salt
     Encrypt KEY using SALT as the salt value to the crypt(3) library call

 -- primitive: mkstemp! tmpl
     mkstemp creates a new unique file in the file system and returns a new buffered port open for reading and writing to the file.  TMPL is a string specifying where the file should be created: it must end with XXXXXX and will be changed in place to return the name of the temporary file.

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