X-Git-Url: https://git.hcoop.net/bpt/guile.git/blobdiff_plain/67b7dd9ea9aad459d77785766da3a8e3607ce2ab..e0902d958d83131e1054a8dbf1fba2dbdd211d9a:/NEWS diff --git a/NEWS b/NEWS index ea966c86d..c881afff6 100644 --- a/NEWS +++ b/NEWS @@ -6,12 +6,65 @@ Please send Guile bug reports to bug-guile@gnu.org. Changes since the stable branch: -** Variables have no longer a special behavior for `equal?'. +* Changes to the standalone interpreter + +** New command line option `--no-debug'. + +Specifying `--no-debug' on the command line will keep the debugging +evaluator turned off, even for interactive sessions. + +** User-init file ~/.guile is now loaded with the debugging evaluator. + +Previously, the normal evaluator would have been used. Using the +debugging evaluator gives better error messages. + +* Changes to Scheme functions and syntax + +** Variables have no longer a special behavior for `equal?'. Previously, comparing two variables with `equal?' would recursivly compare their values. This is no longer done. Variables are now only `equal?' if they are `eq?'. +** `(begin)' is now valid. + +You can now use an empty `begin' form. It will yield # +when evaluated and simply be ignored in a definition context. + +** Removed: substring-move-left!, substring-move-right! + +Use `substring-move!' instead. + +* Changes to the C interface + +** New function: scm_str2string + +This function creates a scheme string from a 0-terminated C string. The input +string is copied. + +** Declarations of exported features are marked with SCM_API. + +Every declaration of a feature that belongs to the exported Guile API +has been marked by adding the macro "SCM_API" to the start of the +declaration. This macro can expand into different things, the most +common of which is just "extern" for Unix platforms. On Win32, it can +be used to control which symbols are exported from a DLL. + +If you `#define SCM_IMPORT' before including , SCM_API +will expand into "__declspec (dllimport) extern", which is needed for +linking to the Guile DLL in Windows. + +There are also SCM_RL_IMPORT, QT_IMPORT, SCM_SRFI1314_IMPORT, and +SCM_SRFI4_IMPORT, for the corresponding libraries. + +** SCM_NEWCELL and SCM_NEWCELL2 have been deprecated. + +Use the new functions scm_alloc_cell and scm_alloc_double_cell +instead. The old macros had problems because with them allocation and +initialization was separated and the GC could sometimes observe half +initialized cells. Only careful coding by the user of SCM_NEWCELL and +SCM_NEWCELL2 could make this safe and efficient. + Changes since Guile 1.4: * Changes to the distribution @@ -39,12 +92,24 @@ micro version number. In addition, ./GUILE-VERSION now defines GUILE_MICRO_VERSION. +** New preprocessor definitions are available for checking versions. + +version.h now #defines SCM_MAJOR_VERSION, SCM_MINOR_VERSION, and +SCM_MICRO_VERSION to the appropriate integer values. + ** Guile now actively warns about deprecated features. The new configure option `--enable-deprecated=LEVEL' and the environment variable GUILE_WARN_DEPRECATED control this mechanism. See INSTALL and README for more information. +** Guile is much more likely to work on 64-bit architectures. + +Guile now compiles and passes "make check" with only two UNRESOLVED GC +cases on Alpha and ia64 based machines now. Thanks to John Goerzen +for the use of a test machine, and thanks to Stefan Jahn for ia64 +patches. + ** New functions: setitimer and getitimer. These implement a fairly direct interface to the libc functions of the @@ -256,6 +321,14 @@ default. * Changes to Scheme functions and syntax +** Character classifiers work for non-ASCII characters. + +The predicates `char-alphabetic?', `char-numeric?', +`char-whitespace?', `char-lower?', `char-upper?' and `char-is-both?' +no longer check whether their arguments are ASCII characters. +Previously, a character would only be considered alphabetic when it +was also ASCII, for example. + ** Previously deprecated Scheme functions have been removed: tag - no replacement. @@ -375,6 +448,61 @@ want to re-export bindings, use the new `re-export' in place of `export'. The new `re-export' will not make copies of variables when rexporting them, as `export' did wrongly. +** Module system now allows selection and renaming of imported bindings + +Previously, when using `use-modules' or the `#:use-module' clause in +the `define-module' form, all the bindings (association of symbols to +values) for imported modules were added to the "current module" on an +as-is basis. This has been changed to allow finer control through two +new facilities: selection and renaming. + +You can now select which of the imported module's bindings are to be +visible in the current module by using the `:select' clause. This +clause also can be used to rename individual bindings. For example: + + ;; import all bindings no questions asked + (use-modules (ice-9 common-list)) + + ;; import four bindings, renaming two of them; + ;; the current module sees: every some zonk-y zonk-n + (use-modules ((ice-9 common-list) + :select (every some + (remove-if . zonk-y) + (remove-if-not . zonk-n)))) + +You can also programmatically rename all selected bindings using the +`:renamer' clause, which specifies a proc that takes a symbol and +returns another symbol. Because it is common practice to use a prefix, +we now provide the convenience procedure `symbol-prefix-proc'. For +example: + + ;; import four bindings, renaming two of them specifically, + ;; and all four w/ prefix "CL:"; + ;; the current module sees: CL:every CL:some CL:zonk-y CL:zonk-n + (use-modules ((ice-9 common-list) + :select (every some + (remove-if . zonk-y) + (remove-if-not . zonk-n)) + :renamer (symbol-prefix-proc 'CL:))) + + ;; import four bindings, renaming two of them specifically, + ;; and all four by upcasing. + ;; the current module sees: EVERY SOME ZONK-Y ZONK-N + (define (upcase-symbol sym) + (string->symbol (string-upcase (symbol->string sym)))) + + (use-modules ((ice-9 common-list) + :select (every some + (remove-if . zonk-y) + (remove-if-not . zonk-n)) + :renamer upcase-symbol)) + +Note that programmatic renaming is done *after* individual renaming. +Also, the above examples show `use-modules', but the same facilities are +available for the `#:use-module' clause of `define-module'. + +See manual for more info. + ** The semantics of guardians have changed. The changes are for the most part compatible. An important criterion @@ -681,6 +809,64 @@ Use module system operations for all variables. That is, a call to `throw', `error', etc is now guaranteed to not return. +** Bugfixes for (ice-9 getopt-long) + +This module is now tested using test-suite/tests/getopt-long.test. +The following bugs have been fixed: + +*** Parsing for options that are specified to have `optional' args now checks +if the next element is an option instead of unconditionally taking it as the +option arg. + +*** An error is now thrown for `--opt=val' when the option description +does not specify `(value #t)' or `(value optional)'. This condition used to +be accepted w/o error, contrary to the documentation. + +*** The error message for unrecognized options is now more informative. +It used to be "not a record", an artifact of the implementation. + +*** The error message for `--opt' terminating the arg list (no value), when +`(value #t)' is specified, is now more informative. It used to be "not enough +args". + +*** "Clumped" single-char args now preserve trailing string, use it as arg. +The expansion used to be like so: + + ("-abc5d" "--xyz") => ("-a" "-b" "-c" "--xyz") + +Note that the "5d" is dropped. Now it is like so: + + ("-abc5d" "--xyz") => ("-a" "-b" "-c" "5d" "--xyz") + +This enables single-char options to have adjoining arguments as long as their +constituent characters are not potential single-char options. + +** (ice-9 session) procedure `arity' now works with (ice-9 optargs) `lambda*' + +The `lambda*' and derivative forms in (ice-9 optargs) now set a procedure +property `arglist', which can be retrieved by `arity'. The result is that +`arity' can give more detailed information than before: + +Before: + + guile> (use-modules (ice-9 optargs)) + guile> (define* (foo #:optional a b c) a) + guile> (arity foo) + 0 or more arguments in `lambda*:G0'. + +After: + + guile> (arity foo) + 3 optional arguments: `a', `b' and `c'. + guile> (define* (bar a b #:key c d #:allow-other-keys) a) + guile> (arity bar) + 2 required arguments: `a' and `b', 2 keyword arguments: `c' + and `d', other keywords allowed. + guile> (define* (baz a b #:optional c #:rest r) a) + guile> (arity baz) + 2 required arguments: `a' and `b', 1 optional argument: `c', + the rest in `r'. + * Changes to the C interface ** Types have been renamed from scm_*_t to scm_t_*. @@ -1058,13 +1244,27 @@ intended to be used in user code. You should avoid dealing with bignums directly, and should deal with numbers in general (which can be bignums). +** Change in behavior: scm_num2long, scm_num2ulong + +The scm_num2[u]long functions don't any longer accept an inexact +argument. This change in behavior is motivated by concordance with +R5RS: It is more common that a primitive doesn't want to accept an +inexact for an exact. + ** New functions: scm_short2num, scm_ushort2num, scm_int2num, scm_uint2num, scm_size2num, scm_ptrdiff2num, scm_num2short, scm_num2ushort, scm_num2int, scm_num2uint, scm_num2ptrdiff, scm_num2size. These are conversion functions between the various ANSI C integral -types and Scheme numbers. +types and Scheme numbers. NOTE: The scm_num2xxx functions don't +accept an inexact argument. + +** New functions: scm_float2num, scm_double2num, + scm_num2float, scm_num2double. + +These are conversion functions between the two ANSI C float types and +Scheme numbers. ** New number validation macros: SCM_NUM2{SIZE,PTRDIFF,SHORT,USHORT,INT,UINT}[_DEF]