-Guile NEWS --- history of user-visible changes. -*- text -*-
+Guile NEWS --- history of user-visible changes.
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
See the end for copying conditions.
* Changes to the distribution
-** There is a new thread implementation option: "null".
+** 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
is always present, although you might not be able to create new
threads.
-When cooperative threading is not supported on your platform, you will
-get the "null" threads.
+The "coop-pthread" (or shorter: "copt") thread implementation will use
+portable POSIX threads but will restrict them so that only one thread
+can execute 'in Guile' at any one time. This option will give you the
+same basic behavior as the old "coop" option, but hopefully in a more
+portable way.
-The long term plan is to make the selection of a thread implementation
-a run-time option, not a configure time option.
+The default is now "coop-pthread", unless your platform doesn't have
+pthreads, in which case "null" threads are used.
** Guile now includes its own version of libltdl.
* Changes to Scheme functions and syntax
+** 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'.
+
+This function will attempt to lock a mutex but will return immediately
+instead if blocking and indicate failure.
+
+** Waiting on a condition variable can have a timeout.
+
+The funtion 'wait-condition-variable' now takes a third, optional
+argument that specifies the point in time where the waiting should be
+aborted.
+
+** New function 'broadcast-condition-variable'.
+
** New functions 'all-threads' and 'current-thread'.
** Signals and system asyncs work better with threads.
that returns the number of characters that can be read immediately
without the soft port blocking.
+** New debugging feature: breakpoints.
+
+Guile now has breakpoints. For details see the `Debugging Features'
+chapter in the reference manual.
+
+** Deprecated: undefine
+
+There is no replacement for undefine.
+
* 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
+arguments are now passed directly:
+
+ SCM scm_call_with_new_thread (SCM thunk, SCM handler);
+
+This is an incompatible change.
+
** The value 'scm_mask_ints' is no longer writable.
Previously, you could set scm_mask_ints directly. This is no longer
Full number of arguments checking of closures is mandatory now. However, the
option to disable the checking has most probably not been used anyway.
+** Deprecated configure flags USE_THREADS and GUILE_ISELECT
+
+Previously, when the C preprocessor macro USE_THREADS was defined,
+libguile included a thread API. This API is now always included, even
+when threads are not really supported. Thus, you don't need to test
+for USE_THREADS.
+
+Analogously, GUILE_ISELECT was defined when the function
+scm_internal_select was provided by Guile. This function is now
+always defined, and GUILE_ISELECT with it.
+
** Removed definitions: scm_lisp_nil, scm_lisp_t, s_nil_ify, scm_m_nil_ify,
s_t_ify, scm_m_t_ify, s_0_cond, scm_m_0_cond, s_0_ify, scm_m_0_ify, s_1_ify,
scm_m_1_ify, scm_debug_newcell, scm_debug_newcell2, scm_tc16_allocated,
mode: outline
paragraph-separate: "[ \f]*$"
end:
-