-Guile NEWS --- history of user-visible changes. -*- text -*-
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+Guile NEWS --- history of user-visible changes.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
See the end for copying conditions.
Please send Guile bug reports to bug-guile@gnu.org.
* Changes to the distribution
-** There are two new thread implementation options: "null" and
- "coop-pthreads".
+** Guile now provide and uses an "effective" version number.
+
+Guile now provides scm_effective_version and effective-version
+functions which return the "effective" version number. This is just
+the normal full version string without the final micro-version number,
+so the current effective-version is "1.6". The effective version
+should remain unchanged during a stable series, and should be used for
+items like the versioned share directory name
+i.e. /usr/share/guile/1.6.
+
+Providing an unchanging version number during a stable release for
+things like the versioned share directory can be particularly
+important for Guile "add-on" packages, since it provides a directory
+that they can install to that won't be changed out from under them
+with each micro release during a stable series.
+
+** There are two new thread implementation options: "null" and "coop-pthreads".
When you configure "--with-threads=null", you will get the usual
threading API (call-with-new-thread, make-mutex, etc), but you can't
* Changes to Scheme functions and syntax
-** Mutexes are now recursive.
+** 'call-with-current-continuation' is now also available under the name
+ 'call/cc'.
+
+** Checking for duplicate bindings in module system
+
+The module system now can check for name conflicts among imported
+bindings.
+
+The behavior can be controlled by specifying one or more duplicates
+handlers. For example, to make Guile return an error for every name
+collision, write:
+
+(define-module (foo)
+ :use-module (bar)
+ :use-module (baz)
+ :duplicates check)
+
+The new default behavior of the module system when a name collision
+has been detected is to
+
+ 1. Give priority to bindings marked as a replacement.
+ 2. Issue a warning (different warning if overriding core binding).
+ 3. Give priority to the last encountered binding (this corresponds to
+ the old behavior).
+
+If you want the old behavior back without replacements or warnings you
+can add the line:
+
+ (default-duplicate-binding-handler 'last)
+
+to your .guile init file.
+
+The syntax for the :duplicates option is:
+
+ :duplicates HANDLER-NAME | (HANDLER1-NAME HANDLER2-NAME ...)
+
+Specifying multiple handlers is useful since some handlers (such as
+replace) can defer conflict resolution to others. Each handler is
+tried until a binding is selected.
+
+Currently available duplicates handlers are:
+
+ check report an error for bindings with a common name
+ warn issue a warning for bindings with a common name
+ replace replace bindings which have an imported replacement
+ warn-override-core issue a warning for imports which override core bindings
+ and accept the override
+ first select the first encountered binding (override)
+ last select the last encountered binding (override)
+
+These two are provided by the (oop goops) module:
+
+ merge-generics merge generic functions with a common name
+ into an <extended-generic>
+ merge-accessors merge accessors with a common name
-Locking a mutex that you have already locked will now succeed. Every
-call to lock-mutex must be matched with a call to unlock-mutex. Only
-the last call to unlock-mutex will actually unlock the mutex.
+The default duplicates handler is:
+
+ (replace warn-override-core warn last)
+
+A recommended handler (which is likely to correspond to future Guile
+behavior) can be installed with:
+
+ (default-duplicate-binding-handler '(replace warn-override-core check))
+
+** New define-module option: :replace
+
+:replace works as :export, but, in addition, marks the binding as a
+replacement.
+
+A typical example is `format' in (ice-9 format) which is a replacement
+for the core binding `format'.
+
+** Adding prefixes to imported bindings in the module system
+
+There is now a new :use-module option :prefix. It can be used to add
+a prefix to all imported bindings.
+
+ (define-module (foo)
+ :use-module ((bar) :prefix bar:))
+
+will import all bindings exported from bar, but rename them by adding
+the prefix `bar:'.
+
+** Merging generic functions
+
+It is sometimes tempting to use GOOPS accessors with short names.
+For example, it is tempting to use the name `x' for the x-coordinate
+in vector packages.
+
+Assume that we work with a graphical package which needs to use two
+independent vector packages for 2D and 3D vectors respectively. If
+both packages export `x' we will encounter a name collision.
+
+This can now be resolved automagically with the duplicates handler
+`merge-generics' which gives the module system license to merge all
+generic functions sharing a common name:
+
+(define-module (math 2D-vectors)
+ :use-module (oop goops)
+ :export (x y ...))
+
+(define-module (math 3D-vectors)
+ :use-module (oop goops)
+ :export (x y z ...))
+
+(define-module (my-module)
+ :use-module (math 2D-vectors)
+ :use-module (math 3D-vectors)
+ :duplicates merge-generics)
+
+x in (my-module) will now share methods with x in both imported
+modules.
+
+There will, in fact, now be three distinct generic functions named
+`x': x in (2D-vectors), x in (3D-vectors), and x in (my-module). The
+last function will be an <extended-generic>, extending the previous
+two functions.
+
+Let's call the imported generic functions the "ancestor functions". x
+in (my-module) is, in turn, a "descendant function" of the imported
+functions, extending its ancestors.
+
+For any generic function G, the applicable methods are selected from
+the union of the methods of the descendant functions, the methods of G
+itself and the methods of the ancestor functions.
+
+This, ancestor functions share methods with their descendants and vice
+versa. This implies that x in (math 2D-vectors) can will share the
+methods of x in (my-module) and vice versa, while x in (math 2D-vectors)
+doesn't share the methods of x in (math 3D-vectors), thus preserving
+modularity.
+
+Sharing is dynamic, so that adding new methods to a descendant implies
+adding it to the ancestor.
+
+If duplicates checking is desired in the above example, the following
+form of the :duplicates option can be used instead:
+
+ :duplicates (merge-generics check)
+
+** New function: effective-version
+
+Returns the "effective" version number. This is just the normal full
+version string without the final micro-version number. See "Changes
+to the distribution" above.
+
+** Futures
+
+Futures is a way of providing an alternative evaluation policy, very
+similar in principle to "promises". Like promises, futures allow the
+main process to continue instantly, but while promises postpone
+evaluation ("lazy" evaluation) until the value is requested, futures
+immediately starts evaluation in a parallel thread.
+
+Futures are good when you want to express that "I'll need the value of
+this computation sometime soon" and want to allow processing to go on
+in the background until that time arrives.
+
+** New syntax: future FORM
+
+Begin evaluation of FORM in a parallel thread and return the future
+immediately. (Akin to 'delay'.)
+
+** New procedure: future-ref FUTURE
+
+Return the computed value of the future. Wait if the computation is
+not finished. (Akin to 'force'.)
+
+** New syntax: parallel FORM ...
+
+Compute the results of FORM ... in parallel (in a separate thread for
+each form) and return them as multiple values.
+
+** New syntax: letpar ((VAR EXP) ...) BODYFORM ...
+
+Like 'let' but evaluates the binding expressions EXP ... in parallel.
+
+** New functions: par-map, par-for-each PROC ARGLIST ...
+
+Like 'map' and 'for-each' but evaluate the procedure PROC in a
+separate thread for each (set of) argument(s). All applications are
+guaranteed to be completed before the procedure returns.
+
+** New functions: n-par-map, n-par-for-each N PROC ARGLIST ...
+
+Like 'par-map' and 'par-for-each' but evaluate the procedure PROC in N
+threads. This is useful when PROC uses large amounts of resources
+and/or the argument list(s) is/are long so that one thread per (set
+of) argument(s) would consume too much system resources. On a
+dual-CPU system, N = 4 would often be a good choice.
+
+** Fair mutexes and condition variables
+
+Fair mutexes and condition variables have been added. The fairness
+means that scheduling is arranged to give as equal time shares as
+possible and that threads are awakened in a first-in-first-out
+manner. This is not guaranteed with standard mutexes and condition
+variables.
+
+In addition, fair mutexes are recursive. Locking a fair mutex that
+you have already locked will succeed. Every call to lock-mutex must
+be matched with a call to unlock-mutex. Only the last call to
+unlock-mutex will actually unlock the mutex.
+
+A fair condition variable must be used together with a fair mutex,
+just as a standard condition variable must be used together with a
+standard mutex.
+
+** New functions: make-fair-mutex, make-fair-condition-variable'
+
+Make a new fair mutex and a new fair condition variable respectively.
** New function 'try-mutex'.
* Changes to the C interface
+** New function: scm_effective_version
+
+Returns the "effective" version number. This is just the normal full
+version string without the final micro-version number. See "Changes
+to the distribution" above.
+
** The function scm_call_with_new_thread has a new prototype.
Instead of taking a list with the thunk and handler, these two
mode: outline
paragraph-separate: "[ \f]*$"
end:
-
HCoop / bpt / guile.git / blobdiff