*** empty log message ***
[bpt/guile.git] / NEWS
diff --git a/NEWS b/NEWS
index 4c73222..e189ca5 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -1,11 +1,52 @@
-Guile NEWS --- history of user-visible changes.  -*- text -*-
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+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.
 
 Please send Guile bug reports to bug-guile@gnu.org.
 \f
 Changes since the stable branch:
 
+* Changes to the distribution
+
+** 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
+actually create new threads.  Also, "--with-threads=no" is now
+equivalent to "--with-threads=null".  This means that the thread API
+is always present, although you might not be able to create new
+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 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.
+
+We now use a modified version of libltdl that allows us to make
+improvements to it without having to rely on libtool releases.
+
 * Changes to the standalone interpreter
 
 ** New command line option `--no-debug'.
@@ -20,8 +61,138 @@ debugging evaluator gives better error messages.
 
 * 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.
+
+The function 'sigaction' now takes a fourth, optional, argument that
+specifies the thread that the handler should run in.  When the
+argument is omitted, the handler will run in the thread that called
+'sigaction'.
+
+Likewise, 'system-async-mark' takes a second, optional, argument that
+specifies the thread that the async should run in.  When it is
+omitted, the async will run in the thread that called
+'system-async-mark'.
+
+C code can use the new functions scm_sigaction_for_thread and
+scm_system_async_mark_for_thread to pass the new thread argument.
+
+** The function 'system-async' is deprecated.
+
+You can now pass any zero-argument procedure to 'system-async-mark'.
+The function 'system-async' will just return its argument unchanged
+now.
+
+** New functions 'call-with-blocked-asyncs' and
+   'call-with-unblocked-asyncs'
+
+The expression (call-with-blocked-asyncs PROC) will call PROC and will
+block execution of system asyncs for the current thread by one level
+while PROC runs.  Likewise, call-with-unblocked-asyncs will call a
+procedure and will unblock the execution of system asyncs by one
+level for the current thread.
+
+Only system asyncs are affected by these functions.
+
+** The functions 'mask-signals' and 'unmask-signals' are deprecated.
+
+Use 'call-with-blocked-asyncs' or 'call-with-unblocked-asyncs'
+instead.  Those functions are easier to use correctly and can be
+nested.
+
 ** New function 'unsetenv'.
 
+** New macro 'define-syntax-public'.
+
+It works like 'define-syntax' and also exports the defined macro (but
+only on top-level).
+
 ** There is support for Infinity and NaNs.
 
 Following PLT Scheme, Guile can now work with infinite numbers, and
@@ -95,8 +266,95 @@ when evaluated and simply be ignored in a definition context.
 
 Use `substring-move!' instead.
 
+** Deprecated: procedure->macro
+
+Change your code to use either procedure->memoizing-macro or, probably better,
+to use r5rs macros.  Also, be aware that macro expansion will not be done
+during evaluation, but prior to evaluation.
+
+** Soft ports now allow a `char-ready?' procedure
+
+The vector argument to `make-soft-port' can now have a length of
+either 5 or 6.  (Previously the length had to be 5.)  The optional 6th
+element is interpreted as an `input-waiting' thunk -- i.e. a thunk
+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
+possible.  Use scm_c_call_with_blocked_asyncs and
+scm_c_call_with_unblocked_asyncs instead.
+
+** New functions scm_c_call_with_blocked_asyncs and
+   scm_c_call_with_unblocked_asyncs
+
+Like scm_call_with_blocked_asyncs etc. but for C functions.
+
+** New snarfer macro SCM_DEFINE_PUBLIC.
+
+This is like SCM_DEFINE, but also calls scm_c_export for the defined
+function in the init section.
+
+** The snarfer macro SCM_SNARF_INIT is now officially supported.
+
+** New macros SCM_VECTOR_REF and SCM_VECTOR_SET.
+
+Use these in preference to SCM_VELTS.
+
+** The SCM_VELTS macros now returns a read-only vector. For writing,
+use the new macros SCM_WRITABLE_VELTS or SCM_VECTOR_SET.  The use of
+SCM_WRITABLE_VELTS is discouraged, though.
+
+** Garbage collector rewrite.
+
+The garbage collector is cleaned up a lot, and now uses lazy
+sweeping. This is reflected in the output of (gc-stats); since cells
+are being freed when they are allocated, the cells-allocated field
+stays roughly constant.
+
+For malloc related triggers, the behavior is changed. It uses the same
+heuristic as the cell-triggered collections.  It may be tuned with the
+environment variables GUILE_MIN_YIELD_MALLOC.  This is the percentage
+for minimum yield of malloc related triggers. The default is 40.
+GUILE_INIT_MALLOC_LIMIT sets the initial trigger for doing a GC. The
+default is 200 kb.
+
+Debugging operations for the freelist have been deprecated, along with
+the C variables that control garbage collection.  The environment
+variables GUILE_MAX_SEGMENT_SIZE, GUILE_INIT_SEGMENT_SIZE_2,
+GUILE_INIT_SEGMENT_SIZE_1, and GUILE_MIN_YIELD_2 should be used.
+
+** The function scm_definedp has been renamed to scm_defined_p
+
+The name scm_definedp is deprecated.
+
 ** The struct scm_cell has been renamed to scm_t_cell
 
 This is in accordance to Guile's naming scheme for types.  Note that
@@ -113,9 +371,9 @@ cause aborts in long running programs.
 The new functions are more symmetrical and do not need cooperation
 from smob free routines, among other improvements.
 
-The new functions are scm_malloc, scm_realloc, scm_strdup,
-scm_strndup, scm_gc_malloc, scm_gc_realloc, scm_gc_free,
-scm_gc_register_collectable_memory, and
+The new functions are scm_malloc, scm_realloc, scm_calloc, scm_strdup,
+scm_strndup, scm_gc_malloc, scm_gc_calloc, scm_gc_realloc,
+scm_gc_free, scm_gc_register_collectable_memory, and
 scm_gc_unregister_collectable_memory.  Refer to the manual for more
 details and for upgrading instructions.
 
@@ -159,6 +417,12 @@ instead.
 
 Use scm_c_source_property_breakpoint_p instead.
 
+** Deprecated: scm_makmacro
+
+Change your code to use either scm_makmmacro or, probably better, to use r5rs
+macros.  Also, be aware that macro expansion will not be done during
+evaluation, but prior to evaluation.
+
 ** Removed from scm_root_state: def_inp, def_outp, def_errp, together
 with corresponding macros scm_def_inp, scm_def_outp and scm_def_errp.
 These were undocumented and unused copies of the standard ports at the
@@ -183,6 +447,17 @@ option to disable the checking has most probably not been used anyway.
 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,
@@ -6152,4 +6427,3 @@ Local variables:
 mode: outline
 paragraph-separate: "[         \f]*$"
 end:
-