X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/867cf9bedd977c9a70fd9349cb0e550e5f6f44df..e963ac2c54f29375c1eca300e63286a72d2ad649:/NEWS diff --git a/NEWS b/NEWS index f31db5422..e189ca5b4 100644 --- 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. 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,6 +61,181 @@ 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 +'not-a-numbers'. + +There is new syntax for numbers: "+inf.0" (infinity), "-inf.0" +(negative infinity), "+nan.0" (not-a-number), and "-nan.0" (same as +"+nan.0"). These numbers are inexact and have no exact counterpart. + +Dividing by an inexact zero returns +inf.0 or -inf.0, depending on the +sign of the dividend. The infinities are integers, and they answer #t +for both 'even?' and 'odd?'. The +nan.0 value is not an integer and is +not '=' to itself, but '+nan.0' is 'eqv?' to itself. + +For example + + (/ 1 0.0) + => +inf.0 + + (/ 0 0.0) + => +nan.0 + + (/ 0) + ERROR: Numerical overflow + +Two new predicates 'inf?' and 'nan?' can be used to test for the +special values. + +** Inexact zero can have a sign. + +Guile can now distinguish between plus and minus inexact zero, if your +platform supports this, too. The two zeros are equal according to +'=', but not according to 'eqv?'. For example + + (- 0.0) + => -0.0 + + (= 0.0 (- 0.0)) + => #t + + (eqv? 0.0 (- 0.0)) + => #f + ** We now have uninterned symbols. The new function 'make-symbol' will return a uninterned symbol. This @@ -50,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 @@ -68,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. @@ -114,8 +417,46 @@ instead. Use scm_c_source_property_breakpoint_p instead. -** Removed from scm_root_state: def_inp, def_outp, def_errp. These were -unused copies of the standard ports when Guile was initialised. +** 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 +time that Guile was initialised. Normally the current ports should be +used instead, obtained from scm_current_input_port () etc. If an +application needs to retain earlier ports, it should save them in a +gc-protected location. + +** Removed compile time option MEMOIZE_LOCALS + +Now, caching of local variable positions during memoization is mandatory. +However, the option to disable the caching has most probably not been used +anyway. + +** Removed compile time option SCM_RECKLESS + +Full number of arguments checking of closures is mandatory now. However, the +option to disable the checking has most probably not been used anyway. + +** Removed compile time option SCM_CAUTIOUS + +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, @@ -6086,4 +6427,3 @@ Local variables: mode: outline paragraph-separate: "[ ]*$" end: -