 -- Scheme Procedure: environment? obj
 -- C Function: scm_environment_p (obj)
     Return #t if OBJ is an environment, or #f otherwise.

 -- Scheme Procedure: environment-bound? env sym
 -- C Function: scm_environment_bound_p (env, sym)
     Return #t if SYM is bound in ENV, or #f otherwise.

 -- Scheme Procedure: environment-ref env sym
 -- C Function: scm_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.

 -- Scheme Procedure: environment-fold env proc init
 -- C Function: scm_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))
                                '()))

 -- Scheme Procedure: environment-define env sym val
 -- C Function: scm_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.

 -- Scheme Procedure: environment-undefine env sym
 -- C Function: scm_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.

 -- Scheme Procedure: environment-set! env sym val
 -- C Function: scm_environment_set_x (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.

 -- Scheme Procedure: environment-cell env sym for_write
 -- C Function: scm_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.

 -- Scheme Procedure: environment-observe env proc
 -- C Function: scm_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.

 -- Scheme Procedure: environment-observe-weak env proc
 -- C Function: scm_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.

 -- Scheme Procedure: environment-unobserve token
 -- C Function: scm_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.

 -- Scheme Procedure: make-leaf-environment
 -- C Function: scm_make_leaf_environment ()
     Create a new leaf environment, containing no bindings. All bindings and locations created in the new environment will be mutable.

 -- Scheme Procedure: leaf-environment? object
 -- C Function: scm_leaf_environment_p (object)
     Return #t if object is a leaf environment, or #f otherwise.

 -- Scheme Procedure: make-eval-environment local imported
 -- C Function: scm_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

 -- Scheme Procedure: eval-environment? object
 -- C Function: scm_eval_environment_p (object)
     Return #t if object is an eval environment, or #f otherwise.

 -- Scheme Procedure: eval-environment-local env
 -- C Function: scm_eval_environment_local (env)
     Return the local environment of eval environment ENV.

 -- Scheme Procedure: eval-environment-set-local! env local
 -- C Function: scm_eval_environment_set_local_x (env, local)
     Change ENV's local environment to LOCAL.

 -- Scheme Procedure: eval-environment-imported env
 -- C Function: scm_eval_environment_imported (env)
     Return the imported environment of eval environment ENV.

 -- Scheme Procedure: eval-environment-set-imported! env imported
 -- C Function: scm_eval_environment_set_imported_x (env, imported)
     Change ENV's imported environment to IMPORTED.

 -- Scheme Procedure: make-import-environment imports conflict_proc
 -- C Function: scm_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.

 -- Scheme Procedure: import-environment? object
 -- C Function: scm_import_environment_p (object)
     Return #t if object is an import environment, or #f otherwise.

 -- Scheme Procedure: import-environment-imports env
 -- C Function: scm_import_environment_imports (env)
     Return the list of environments imported by the import environment ENV.

 -- Scheme Procedure: import-environment-set-imports! env imports
 -- C Function: scm_import_environment_set_imports_x (env, imports)
     Change ENV's list of imported environments to IMPORTS, and check for conflicts.

 -- Scheme Procedure: make-export-environment private signature
 -- C Function: scm_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.

 -- Scheme Procedure: export-environment? object
 -- C Function: scm_export_environment_p (object)
     Return #t if object is an export environment, or #f otherwise.

 -- Scheme Procedure: export-environment-private env
 -- C Function: scm_export_environment_private (env)
     Return the private environment of export environment ENV.

 -- Scheme Procedure: export-environment-set-private! env private
 -- C Function: scm_export_environment_set_private_x (env, private)
     Change the private environment of export environment ENV.

 -- Scheme Procedure: export-environment-signature env
 -- C Function: scm_export_environment_signature (env)
     Return the signature of export environment ENV.

 -- Scheme Procedure: export-environment-set-signature! env signature
 -- C Function: scm_export_environment_set_signature_x (env, signature)
     Change the signature of export environment ENV.

 -- Scheme Procedure: %compute-slots class
 -- C Function: scm_sys_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 super-classes.

 -- Scheme Procedure: get-keyword key l default_value
 -- C Function: scm_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.

 -- Scheme Procedure: slot-ref-using-class class obj slot_name
 -- C Function: scm_slot_ref_using_class (class, obj, slot_name)

 -- Scheme Procedure: slot-set-using-class! class obj slot_name value
 -- C Function: scm_slot_set_using_class_x (class, obj, slot_name, value)

 -- Scheme Procedure: class-of x
 -- C Function: scm_class_of (x)
     Return the class of X.

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

 -- Scheme Procedure: %method-more-specific? m1 m2 targs
 -- C Function: scm_sys_method_more_specific_p (m1, m2, targs)

 -- Scheme Procedure: find-method . l
 -- C Function: scm_find_method (l)

 -- Scheme Procedure: primitive-generic-generic subr
 -- C Function: scm_primitive_generic_generic (subr)

 -- Scheme Procedure: enable-primitive-generic! . subrs
 -- C Function: scm_enable_primitive_generic_x (subrs)

 -- Scheme Procedure: generic-capability? proc
 -- C Function: scm_generic_capability_p (proc)

 -- Scheme Procedure: %invalidate-method-cache! gf
 -- C Function: scm_sys_invalidate_method_cache_x (gf)

 -- Scheme Procedure: %invalidate-class class
 -- C Function: scm_sys_invalidate_class (class)

 -- Scheme Procedure: %modify-class old new
 -- C Function: scm_sys_modify_class (old, new)

 -- Scheme Procedure: %modify-instance old new
 -- C Function: scm_sys_modify_instance (old, new)

 -- Scheme Procedure: %set-object-setter! obj setter
 -- C Function: scm_sys_set_object_setter_x (obj, setter)

 -- Scheme Procedure: %allocate-instance class initargs
 -- C Function: scm_sys_allocate_instance (class, initargs)
     Create a new instance of class CLASS and initialize it from the arguments INITARGS.

 -- Scheme Procedure: slot-exists? obj slot_name
 -- C Function: scm_slots_exists_p (obj, slot_name)
     Return #t if OBJ has a slot named SLOT_NAME.

 -- Scheme Procedure: slot-bound? obj slot_name
 -- C Function: scm_slot_bound_p (obj, slot_name)
     Return #t if the slot named SLOT_NAME of OBJ is bound.

 -- Scheme Procedure: slot-set! obj slot_name value
 -- C Function: scm_slot_set_x (obj, slot_name, value)
     Set the slot named SLOT_NAME of OBJ to VALUE.

 -- Scheme Procedure: slot-exists-using-class? class obj slot_name
 -- C Function: scm_slot_exists_using_class_p (class, obj, slot_name)

 -- Scheme Procedure: slot-bound-using-class? class obj slot_name
 -- C Function: scm_slot_bound_using_class_p (class, obj, slot_name)

 -- Scheme Procedure: %fast-slot-set! obj index value
 -- C Function: scm_sys_fast_slot_set_x (obj, index, value)
     Set the slot with index INDEX in OBJ to VALUE.

 -- Scheme Procedure: %fast-slot-ref obj index
 -- C Function: scm_sys_fast_slot_ref (obj, index)
     Return the slot value with index INDEX from OBJ.

 -- Scheme Procedure: @assert-bound-ref obj index
 -- C Function: scm_at_assert_bound_ref (obj, index)
     Like assert-bound, but use INDEX for accessing the value from OBJ.

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

 -- Scheme Procedure: unbound? obj
 -- C Function: scm_unbound_p (obj)
     Return #t if OBJ is unbound.

 -- Scheme Procedure: make-unbound
 -- C Function: scm_make_unbound ()
     Return the unbound value.

 -- Scheme Procedure: accessor-method-slot-definition obj
 -- C Function: scm_accessor_method_slot_definition (obj)
     Return the slot definition of the accessor OBJ.

 -- Scheme Procedure: method-procedure obj
 -- C Function: scm_method_procedure (obj)
     Return the procedure of the method OBJ.

 -- Scheme Procedure: method-specializers obj
 -- C Function: scm_method_specializers (obj)
     Return specializers of the method OBJ.

 -- Scheme Procedure: method-generic-function obj
 -- C Function: scm_method_generic_function (obj)
     Return the generic function for the method OBJ.

 -- Scheme Procedure: generic-function-methods obj
 -- C Function: scm_generic_function_methods (obj)
     Return the methods of the generic function OBJ.

 -- Scheme Procedure: generic-function-name obj
 -- C Function: scm_generic_function_name (obj)
     Return the name of the generic function OBJ.

 -- Scheme Procedure: class-environment obj
 -- C Function: scm_class_environment (obj)
     Return the environment of the class OBJ.

 -- Scheme Procedure: class-slots obj
 -- C Function: scm_class_slots (obj)
     Return the slot list of the class OBJ.

 -- Scheme Procedure: class-precedence-list obj
 -- C Function: scm_class_precedence_list (obj)
     Return the class precedence list of the class OBJ.

 -- Scheme Procedure: class-direct-methods obj
 -- C Function: scm_class_direct_methods (obj)
     Return the direct methods of the class OBJ

 -- Scheme Procedure: class-direct-subclasses obj
 -- C Function: scm_class_direct_subclasses (obj)
     Return the direct subclasses of the class OBJ.

 -- Scheme Procedure: class-direct-slots obj
 -- C Function: scm_class_direct_slots (obj)
     Return the direct slots of the class OBJ.

 -- Scheme Procedure: class-direct-supers obj
 -- C Function: scm_class_direct_supers (obj)
     Return the direct super-classes of the class OBJ.

 -- Scheme Procedure: class-name obj
 -- C Function: scm_class_name (obj)
     Return the class name of OBJ.

 -- Scheme Procedure: instance? obj
 -- C Function: scm_instance_p (obj)
     Return #t if OBJ is an instance.

 -- Scheme Procedure: %inherit-magic! class dsupers
 -- C Function: scm_sys_inherit_magic_x (class, dsupers)

 -- Scheme Procedure: %prep-layout! class
 -- C Function: scm_sys_prep_layout_x (class)

 -- Scheme Procedure: %initialize-object obj initargs
 -- C Function: scm_sys_initialize_object (obj, initargs)
     Initialize the object OBJ with the given arguments INITARGS.

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

 -- Scheme Procedure: slot-ref obj slot_name
 -- C Function: scm_slot_ref (obj, slot_name)
     Return the value from OBJ's slot with the name SLOT_NAME.

 -- Scheme Procedure: %tag-body body
 -- C Function: scm_sys_tag_body (body)
     Internal GOOPS magic---don't use this function!

 -- Scheme Procedure: list*
     implemented by the C function "scm_cons_star"

 -- Scheme Procedure: set-current-module module
 -- C Function: scm_set_current_module (module)
     Set the current module to MODULE and return the previous current module.

 -- Scheme Procedure: current-module
 -- C Function: scm_current_module ()
     Return the current module.

 -- Scheme Procedure: c-clear-registered-modules
     Destroy the list of modules registered with the current Guile process. The return value is unspecified.  Warning: this function does not actually unlink or deallocate these modules, but only destroys the records of which modules have been loaded.  It should therefore be used only by module bookkeeping operations.

 -- Scheme Procedure: c-registered-modules
     Return a list of the object code modules that have been imported into the current Guile process.  Each element of the list is a pair whose car is the name of the module, and whose cdr is the function handle for that module's initializer function.  The name is the string that has been passed to scm_register_module_xxx.

 -- Scheme Procedure: include-deprecated-features
     Return #t iff deprecated features should be included in public interfaces.

 -- Scheme Procedure: issue-deprecation-warning . msgs
     Output MSGS to (current-error-port) when this is the first call to issue-deprecation-warning with this specific MSG.  Do nothing otherwise. The argument MSGS should be a list of strings; they are printed in turn, each one followed by a newline.

 -- Scheme Procedure: valid-object-procedure? proc
 -- C Function: scm_valid_object_procedure_p (proc)
     Return #t iff PROC is a procedure that can be used with set-object-procedure.  It is always valid to use a closure constructed by lambda.

 -- Scheme Procedure: %get-pre-modules-obarray
 -- C Function: scm_get_pre_modules_obarray ()
     Return the obarray that is used for all new bindings before the module system is booted.  The first call to set-current-module will boot the module system.

 -- Scheme Procedure: standard-interface-eval-closure module
 -- C Function: scm_standard_interface_eval_closure (module)
     Return a interface eval closure for the module MODULE. Such a closure does not allow new bindings to be added.

 -- Scheme Procedure: env-module env
 -- C Function: scm_env_module (env)
     Return the module of ENV, a lexical environment.

 -- Scheme Procedure: load-extension lib init
 -- C Function: scm_load_extension (lib, init)
     Load and initialize the extension designated by LIB and INIT. When there is no pre-registered function for LIB/INIT, this is equivalent to

          (dynamic-call INIT (dynamic-link LIB))

     When there is a pre-registered function, that function is called instead.

     Normally, there is no pre-registered function.  This option exists only for situations where dynamic linking is unavailable or unwanted. In that case, you would statically link your program with the desired library, and register its init function right after Guile has been initialized.

     LIB should be a string denoting a shared library without any file type suffix such as ".so".  The suffix is provided automatically.  It should also not contain any directory components.  Libraries that implement Guile Extensions should be put into the normal locations for shared libraries.  We recommend to use the naming convention libguile-bla-blum for a extension related to a module `(bla blum)'.

     The normal way for a extension to be used is to write a small Scheme file that defines a module, and to load the extension into this module.  When the module is auto-loaded, the extension is loaded as well.  For example,

          (define-module (bla blum))

          (load-extension "libguile-bla-blum" "bla_init_blum")

 -- Scheme Procedure: single-active-thread?
     implemented by the C function "scm_single_thread_p"

 -- Scheme Procedure: object-address obj
 -- C Function: scm_object_address (obj)
     Return an integer that for the lifetime of OBJ is uniquely returned by this function for OBJ