This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "GNU Guile".
http://git.savannah.gnu.org/cgit/guile.git/commit/?id=22f68e8b4cea2ce96b238aaffceaaf2fdaafbe6f The branch, master has been updated via 22f68e8b4cea2ce96b238aaffceaaf2fdaafbe6f (commit) via 175323953a77761c0e73f49fc87787dbc98d73c7 (commit) from 664a8b0d66e2e062e9946f41707855a588b489eb (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 22f68e8b4cea2ce96b238aaffceaaf2fdaafbe6f Author: Neil Jerram <n...@ossau.uklinux.net> Date: Sat Sep 11 16:34:19 2010 +0100 Remove non-existent *environment* APIs from api-undocumented.texi * doc/ref/api-undocumented.texi: Remove entries for the never used, and now removed, environment API. commit 175323953a77761c0e73f49fc87787dbc98d73c7 Author: Neil Jerram <n...@ossau.uklinux.net> Date: Sat Sep 11 15:45:05 2010 +0100 Remove unnecessary blank "Indices" page. * doc/ref/guile.texi: Remove `Indices' heading. ----------------------------------------------------------------------- Summary of changes: doc/ref/api-undocumented.texi | 319 ----------------------------------------- doc/ref/guile.texi | 5 - 2 files changed, 0 insertions(+), 324 deletions(-) diff --git a/doc/ref/api-undocumented.texi b/doc/ref/api-undocumented.texi index cae96bc..774061d 100644 --- a/doc/ref/api-undocumented.texi +++ b/doc/ref/api-undocumented.texi @@ -4,9 +4,6 @@ for various reasons, mostly because they have been deprecated. They are here in this file to give docstring.el a chance to update them automatically. -- The 'environments' are only in Guile by accident and are not used at - all and we don't want to advertise them. - - GOOPS is documented in its own manual. @@ -267,322 +264,6 @@ Return an integer that for the lifetime of @var{obj} is uniquely returned by this function for @var{obj} @end deffn -...@deffn {Scheme Procedure} environment? obj -...@deffnx {C Function} scm_environment_p (obj) -Return @code{#t} if @var{obj} is an environment, or @code{#f} -otherwise. -...@end deffn - -...@deffn {Scheme Procedure} environment-bound? env sym -...@deffnx {C Function} scm_environment_bound_p (env, sym) -Return @code{#t} if @var{sym} is bound in @var{env}, or -...@code{#f} otherwise. -...@end deffn - -...@deffn {Scheme Procedure} environment-ref env sym -...@deffnx {C Function} scm_environment_ref (env, sym) -Return the value of the location bound to @var{sym} in -...@var{env}. If @var{sym} is unbound in @var{env}, signal an -...@code{environment:unbound} error. -...@end deffn - -...@deffn {Scheme Procedure} environment-fold env proc init -...@deffnx {C Function} scm_environment_fold (env, proc, init) -Iterate over all the bindings in @var{env}, accumulating some -value. -For each binding in @var{env}, apply @var{proc} to the symbol -bound, its value, and the result from the previous application -of @var{proc}. -Use @var{init} as @var{proc}'s third argument the first time -...@var{proc} is applied. -If @var{env} contains no bindings, this function simply returns -...@var{init}. -If @var{env} binds the symbol sym1 to the value val1, sym2 to -val2, and so on, then this procedure computes: -...@lisp - (proc sym1 val1 - (proc sym2 val2 - ... - (proc symn valn - init))) -...@end lisp -Each binding in @var{env} will be processed exactly once. -...@code{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: -...@lisp - (define (environment->alist env) - (environment-fold env - (lambda (sym val tail) - (cons (cons sym val) tail)) - '())) -...@end lisp -...@end deffn - -...@deffn {Scheme Procedure} environment-define env sym val -...@deffnx {C Function} scm_environment_define (env, sym, val) -Bind @var{sym} to a new location containing @var{val} in -...@var{env}. If @var{sym} is already bound to another location -in @var{env} and the binding is mutable, that binding is -replaced. The new binding and location are both mutable. The -return value is unspecified. -If @var{sym} is already bound in @var{env}, and the binding is -immutable, signal an @code{environment:immutable-binding} error. -...@end deffn - -...@deffn {Scheme Procedure} environment-undefine env sym -...@deffnx {C Function} scm_environment_undefine (env, sym) -Remove any binding for @var{sym} from @var{env}. If @var{sym} -is unbound in @var{env}, do nothing. The return value is -unspecified. -If @var{sym} is already bound in @var{env}, and the binding is -immutable, signal an @code{environment:immutable-binding} error. -...@end deffn - -...@deffn {Scheme Procedure} environment-set! env sym val -...@deffnx {C Function} scm_environment_set_x (env, sym, val) -If @var{env} binds @var{sym} to some location, change that -location's value to @var{val}. The return value is -unspecified. -If @var{sym} is not bound in @var{env}, signal an -...@code{environment:unbound} error. If @var{env} binds @var{sym} -to an immutable location, signal an -...@code{environment:immutable-location} error. -...@end deffn - -...@deffn {Scheme Procedure} environment-cell env sym for_write -...@deffnx {C Function} scm_environment_cell (env, sym, for_write) -Return the value cell which @var{env} binds to @var{sym}, or -...@code{#f} if the binding does not live in a value cell. -The argument @var{for-write} indicates whether the caller -intends to modify the variable's value by mutating the value -cell. If the variable is immutable, then -...@code{environment-cell} signals an -...@code{environment:immutable-location} error. -If @var{sym} is unbound in @var{env}, signal an -...@code{environment:unbound} error. -If you use this function, you should consider using -...@code{environment-observe}, to be notified when @var{sym} gets -re-bound to a new value cell, or becomes undefined. -...@end deffn - -...@deffn {Scheme Procedure} environment-observe env proc -...@deffnx {C Function} scm_environment_observe (env, proc) -Whenever @var{env}'s bindings change, apply @var{proc} to -...@var{env}. -This function returns an object, token, which you can pass to -...@code{environment-unobserve} to remove @var{proc} from the set -of procedures observing @var{env}. The type and value of -token is unspecified. -...@end deffn - -...@deffn {Scheme Procedure} environment-observe-weak env proc -...@deffnx {C Function} scm_environment_observe_weak (env, proc) -This function is the same as environment-observe, except that -the reference @var{env} retains to @var{proc} is a weak -reference. This means that, if there are no other live, -non-weak references to @var{proc}, it will be -garbage-collected, and dropped from @var{env}'s -list of observing procedures. -...@end deffn - -...@deffn {Scheme Procedure} environment-unobserve token -...@deffnx {C Function} scm_environment_unobserve (token) -Cancel the observation request which returned the value -...@var{token}. The return value is unspecified. -If a call @code{(environment-observe env proc)} returns -...@var{token}, then the call @code{(environment-unobserve token)} -will cause @var{proc} to no longer be called when @var{env}'s -bindings change. -...@end deffn - -...@deffn {Scheme Procedure} make-leaf-environment -...@deffnx {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. -...@end deffn - -...@deffn {Scheme Procedure} leaf-environment? object -...@deffnx {C Function} scm_leaf_environment_p (object) -Return @code{#t} if object is a leaf environment, or @code{#f} -otherwise. -...@end deffn - -...@deffn {Scheme Procedure} make-eval-environment local imported -...@deffnx {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 @var{local} and -...@var{imported}, with bindings from @var{local} taking -precedence. Definitions made in eval are placed in @var{local}. -Applying @code{environment-define} or -...@code{environment-undefine} to eval has the same effect as -applying the procedure to @var{local}. -Note that eval incorporates @var{local} and @var{imported} by -reference: -If, after creating eval, the program changes the bindings of -...@var{local} or @var{imported}, those changes will be visible -in eval. -Since most Scheme evaluation takes place in eval environments, -they transparently cache the bindings received from @var{local} -and @var{imported}. Thus, the first time the program looks up -a symbol in eval, eval may make calls to @var{local} or -...@var{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, @var{local} will be a finite environment, and -...@var{imported} will be an import environment -...@end deffn - -...@deffn {Scheme Procedure} eval-environment? object -...@deffnx {C Function} scm_eval_environment_p (object) -Return @code{#t} if object is an eval environment, or @code{#f} -otherwise. -...@end deffn - -...@deffn {Scheme Procedure} eval-environment-local env -...@deffnx {C Function} scm_eval_environment_local (env) -Return the local environment of eval environment @var{env}. -...@end deffn - -...@deffn {Scheme Procedure} eval-environment-set-local! env local -...@deffnx {C Function} scm_eval_environment_set_local_x (env, local) -Change @var{env}'s local environment to @var{local}. -...@end deffn - -...@deffn {Scheme Procedure} eval-environment-imported env -...@deffnx {C Function} scm_eval_environment_imported (env) -Return the imported environment of eval environment @var{env}. -...@end deffn - -...@deffn {Scheme Procedure} eval-environment-set-imported! env imported -...@deffnx {C Function} scm_eval_environment_set_imported_x (env, imported) -Change @var{env}'s imported environment to @var{imported}. -...@end deffn - -...@deffn {Scheme Procedure} make-import-environment imports conflict_proc -...@deffnx {C Function} scm_make_import_environment (imports, conflict_proc) -Return a new environment @var{imp} whose bindings are the union -of the bindings from the environments in @var{imports}; -...@var{imports} must be a list of environments. That is, -...@var{imp} binds a symbol to a location when some element of -...@var{imports} does. -If two different elements of @var{imports} have a binding for -the same symbol, the @var{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 @var{conflict-proc} returns an environment @var{env}, -the conflict is considered as resolved and the binding from -...@var{env} is used. If the @var{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 @var{imp} are immutable. If you apply -...@code{environment-define} or @code{environment-undefine} to -...@var{imp}, Guile will signal an - @code{environment:immutable-binding} error. However, -notice that the set of bindings in @var{imp} may still change, -if one of its imported environments changes. -...@end deffn - -...@deffn {Scheme Procedure} import-environment? object -...@deffnx {C Function} scm_import_environment_p (object) -Return @code{#t} if object is an import environment, or -...@code{#f} otherwise. -...@end deffn - -...@deffn {Scheme Procedure} import-environment-imports env -...@deffnx {C Function} scm_import_environment_imports (env) -Return the list of environments imported by the import -environment @var{env}. -...@end deffn - -...@deffn {Scheme Procedure} import-environment-set-imports! env imports -...@deffnx {C Function} scm_import_environment_set_imports_x (env, imports) -Change @var{env}'s list of imported environments to -...@var{imports}, and check for conflicts. -...@end deffn - -...@deffn {Scheme Procedure} make-export-environment private signature -...@deffnx {C Function} scm_make_export_environment (private, signature) -Return a new environment @var{exp} containing only those -bindings in private whose symbols are present in -...@var{signature}. The @var{private} argument must be an -environment. - -The environment @var{exp} binds symbol to location when -...@var{env} does, and symbol is exported by @var{signature}. - -...@var{signature} is a list specifying which of the bindings in -...@var{private} should be visible in @var{exp}. Each element of -...@var{signature} should be a list of the form: - (symbol attribute ...) -where each attribute is one of the following: -...@table @asis -...@item the symbol @code{mutable-location} - @var{exp} should treat the - location bound to symbol as mutable. That is, @var{exp} - will pass calls to @code{environment-set!} or - @code{environment-cell} directly through to private. -...@item the symbol @code{immutable-location} - @var{exp} should treat - the location bound to symbol as immutable. If the program - applies @code{environment-set!} to @var{exp} and symbol, or - calls @code{environment-cell} to obtain a writable value - cell, @code{environment-set!} will signal an - @code{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. -...@end table -It is an error for an element of signature to specify both -...@code{mutable-location} and @code{immutable-location}. If -neither is specified, @code{immutable-location} is assumed. - -As a special case, if an element of signature is a lone -symbol @var{sym}, it is equivalent to an element of the form -...@code{(sym)}. - -All bindings in @var{exp} are immutable. If you apply -...@code{environment-define} or @code{environment-undefine} to -...@var{exp}, Guile will signal an -...@code{environment:immutable-binding} error. However, -notice that the set of bindings in @var{exp} may still change, -if the bindings in private change. -...@end deffn - -...@deffn {Scheme Procedure} export-environment? object -...@deffnx {C Function} scm_export_environment_p (object) -Return @code{#t} if object is an export environment, or -...@code{#f} otherwise. -...@end deffn - -...@deffn {Scheme Procedure} export-environment-private env -...@deffnx {C Function} scm_export_environment_private (env) -Return the private environment of export environment @var{env}. -...@end deffn - -...@deffn {Scheme Procedure} export-environment-set-private! env private -...@deffnx {C Function} scm_export_environment_set_private_x (env, private) -Change the private environment of export environment @var{env}. -...@end deffn - -...@deffn {Scheme Procedure} export-environment-signature env -...@deffnx {C Function} scm_export_environment_signature (env) -Return the signature of export environment @var{env}. -...@end deffn - -...@deffn {Scheme Procedure} export-environment-set-signature! env signature -...@deffnx {C Function} scm_export_environment_set_signature_x (env, signature) -Change the signature of export environment @var{env}. -...@end deffn - @deffn {Scheme Procedure} %compute-slots class @deffnx {C Function} scm_sys_compute_slots (class) Return a list consisting of the names of all slots belonging to diff --git a/doc/ref/guile.texi b/doc/ref/guile.texi index 1f57343..9db1a1a 100644 --- a/doc/ref/guile.texi +++ b/doc/ref/guile.texi @@ -430,11 +430,6 @@ merely familiar with Scheme to being a real hacker. @include fdl.texi -...@iftex -...@page -...@unnumbered{indices} -...@end iftex - @include indices.texi @include scheme-indices.texi hooks/post-receive -- GNU Guile
