X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/3ffc7a360f053673fb5dc578c1a2334d0a07c653..cc36e791ad17b77e0f89b6c03034990fdf709971:/NEWS diff --git a/NEWS b/NEWS index fc50e9294..2626a0d09 100644 --- a/NEWS +++ b/NEWS @@ -1,11 +1,1405 @@ Guile NEWS --- history of user-visible changes. -*- text -*- -Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc. +Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc. See the end for copying conditions. Please send Guile bug reports to bug-guile@gnu.org. +Changes since Guile 1.3.4: + + +Changes since Guile 1.3.2: + +* Changes to the stand-alone interpreter + +** Debugger + +An initial version of the Guile debugger written by Chris Hanson has +been added. The debugger is still under development but is included +in the distribution anyway since it is already quite useful. + +Type + + (debug) + +after an error to enter the debugger. Type `help' inside the debugger +for a description of available commands. + +If you prefer to have stack frames numbered and printed in +anti-chronological order and prefer up in the stack to be down on the +screen as is the case in gdb, you can put + + (debug-enable 'backwards) + +in your .guile startup file. (However, this means that Guile can't +use indentation to indicate stack level.) + +The debugger is autoloaded into Guile at the first use. + +** Further enhancements to backtraces + +There is a new debug option `width' which controls the maximum width +on the screen of printed stack frames. Fancy printing parameters +("level" and "length" as in Common LISP) are adaptively adjusted for +each stack frame to give maximum information while still fitting +within the bounds. If the stack frame can't be made to fit by +adjusting parameters, it is simply cut off at the end. This is marked +with a `$'. + +** Some modules are now only loaded when the repl is started + +The modules (ice-9 debug), (ice-9 session), (ice-9 threads) and (ice-9 +regex) are now loaded into (guile-user) only if the repl has been +started. The effect is that the startup time for scripts has been +reduced to 30% of what it was previously. + +Correctly written scripts load the modules they require at the top of +the file and should not be affected by this change. + +** Hooks are now represented as smobs + +* Changes to Scheme functions and syntax + +** Readline support has changed again. + +The old (readline-activator) module is gone. Use (ice-9 readline) +instead, which now contains all readline functionality. So the code +to activate readline is now + + (use-modules (ice-9 readline)) + (activate-readline) + +This should work at any time, including from the guile prompt. + +To avoid confusion about the terms of Guile's license, please only +enable readline for your personal use; please don't make it the +default for others. Here is why we make this rather odd-sounding +request: + +Guile is normally licensed under a weakened form of the GNU General +Public License, which allows you to link code with Guile without +placing that code under the GPL. This exception is important to some +people. + +However, since readline is distributed under the GNU General Public +License, when you link Guile with readline, either statically or +dynamically, you effectively change Guile's license to the strict GPL. +Whenever you link any strictly GPL'd code into Guile, uses of Guile +which are normally permitted become forbidden. This is a rather +non-obvious consequence of the licensing terms. + +So, to make sure things remain clear, please let people choose for +themselves whether to link GPL'd libraries like readline with Guile. + +** regexp-substitute/global has changed slightly, but incompatibly. + +If you include a function in the item list, the string of the match +object it receives is the same string passed to +regexp-substitute/global, not some suffix of that string. +Correspondingly, the match's positions are relative to the entire +string, not the suffix. + +If the regexp can match the empty string, the way matches are chosen +from the string has changed. regexp-substitute/global recognizes the +same set of matches that list-matches does; see below. + +** New function: list-matches REGEXP STRING [FLAGS] + +Return a list of match objects, one for every non-overlapping, maximal +match of REGEXP in STRING. The matches appear in left-to-right order. +list-matches only reports matches of the empty string if there are no +other matches which begin on, end at, or include the empty match's +position. + +If present, FLAGS is passed as the FLAGS argument to regexp-exec. + +** New function: fold-matches REGEXP STRING INIT PROC [FLAGS] + +For each match of REGEXP in STRING, apply PROC to the match object, +and the last value PROC returned, or INIT for the first call. Return +the last value returned by PROC. We apply PROC to the matches as they +appear from left to right. + +This function recognizes matches according to the same criteria as +list-matches. + +Thus, you could define list-matches like this: + + (define (list-matches regexp string . flags) + (reverse! (apply fold-matches regexp string '() cons flags))) + +If present, FLAGS is passed as the FLAGS argument to regexp-exec. + +** Hooks + +*** New function: hook? OBJ + +Return #t if OBJ is a hook, otherwise #f. + +*** New function: make-hook-with-name NAME [ARITY] + +Return a hook with name NAME and arity ARITY. The default value for +ARITY is 0. The only effect of NAME is that it will appear when the +hook object is printed to ease debugging. + +*** New function: hook-empty? HOOK + +Return #t if HOOK doesn't contain any procedures, otherwise #f. + +*** New function: hook->list HOOK + +Return a list of the procedures that are called when run-hook is +applied to HOOK. + +** `map' signals an error if its argument lists are not all the same length. + +This is the behavior required by R5RS, so this change is really a bug +fix. But it seems to affect a lot of people's code, so we're +mentioning it here anyway. + +** Print-state handling has been made more transparent + +Under certain circumstances, ports are represented as a port with an +associated print state. Earlier, this pair was represented as a pair +(see "Some magic has been added to the printer" below). It is now +indistinguishable (almost; see `get-print-state') from a port on the +user level. + +*** New function: port-with-print-state OUTPUT-PORT PRINT-STATE + +Return a new port with the associated print state PRINT-STATE. + +*** New function: get-print-state OUTPUT-PORT + +Return the print state associated with this port if it exists, +otherwise return #f. + +*** New function: directory-stream? OBJECT + +Returns true iff OBJECT is a directory stream --- the sort of object +returned by `opendir'. + +** New function: using-readline? + +Return #t if readline is in use in the current repl. + +** structs will be removed in 1.4 + +Structs will be replaced in Guile 1.4. We will merge GOOPS into Guile +and use GOOPS objects as the fundamental record type. + +* Changes to the scm_ interface + +** structs will be removed in 1.4 + +The entire current struct interface (struct.c, struct.h) will be +replaced in Guile 1.4. We will merge GOOPS into libguile and use +GOOPS objects as the fundamental record type. + +** The internal representation of subr's has changed + +Instead of giving a hint to the subr name, the CAR field of the subr +now contains an index to a subr entry in scm_subr_table. + +*** New variable: scm_subr_table + +An array of subr entries. A subr entry contains the name, properties +and documentation associated with the subr. The properties and +documentation slots are not yet used. + +** A new scheme for "forwarding" calls to a builtin to a generic function + +It is now possible to extend the functionality of some Guile +primitives by letting them defer a call to a GOOPS generic function on +argument mismatch. This means that there is no loss of efficiency in +normal evaluation. + +Example: + + (use-modules (oop goops)) ; Must be GOOPS version 0.2. + (define-method + ((x ) (y )) + (string-append x y)) + ++ will still be as efficient as usual in numerical calculations, but +can also be used for concatenating strings. + +Who will be the first one to extend Guile's numerical tower to +rationals? :) [OK, there a few other things to fix before this can +be made in a clean way.] + +*** New snarf macros for defining primitives: SCM_GPROC, SCM_GPROC1 + + New macro: SCM_GPROC (CNAME, SNAME, REQ, OPT, VAR, CFUNC, GENERIC) + + New macro: SCM_GPROC1 (CNAME, SNAME, TYPE, CFUNC, GENERIC) + +These do the same job as SCM_PROC and SCM_PROC1, but they also define +a variable GENERIC which can be used by the dispatch macros below. + +[This is experimental code which may change soon.] + +*** New macros for forwarding control to a generic on arg type error + + New macro: SCM_WTA_DISPATCH_1 (GENERIC, ARG1, POS, SUBR) + + New macro: SCM_WTA_DISPATCH_2 (GENERIC, ARG1, ARG2, POS, SUBR) + +These correspond to the scm_wta function call, and have the same +behaviour until the user has called the GOOPS primitive +`enable-primitive-generic!'. After that, these macros will apply the +generic function GENERIC to the argument(s) instead of calling +scm_wta. + +[This is experimental code which may change soon.] + +*** New macros for argument testing with generic dispatch + + New macro: SCM_GASSERT1 (COND, GENERIC, ARG1, POS, SUBR) + + New macro: SCM_GASSERT2 (COND, GENERIC, ARG1, ARG2, POS, SUBR) + +These correspond to the SCM_ASSERT macro, but will defer control to +GENERIC on error after `enable-primitive-generic!' has been called. + +[This is experimental code which may change soon.] + +** New function: SCM scm_eval_body (SCM body, SCM env) + +Evaluates the body of a special form. + +** The internal representation of struct's has changed + +Previously, four slots were allocated for the procedure(s) of entities +and operators. The motivation for this representation had to do with +the structure of the evaluator, the wish to support tail-recursive +generic functions, and efficiency. Since the generic function +dispatch mechanism has changed, there is no longer a need for such an +expensive representation, and the representation has been simplified. + +This should not make any difference for most users. + +** GOOPS support has been cleaned up. + +Some code has been moved from eval.c to objects.c and code in both of +these compilation units has been cleaned up and better structured. + +*** New functions for applying generic functions + + New function: SCM scm_apply_generic (GENERIC, ARGS) + New function: SCM scm_call_generic_0 (GENERIC) + New function: SCM scm_call_generic_1 (GENERIC, ARG1) + New function: SCM scm_call_generic_2 (GENERIC, ARG1, ARG2) + New function: SCM scm_call_generic_3 (GENERIC, ARG1, ARG2, ARG3) + +** Deprecated function: scm_make_named_hook + +It is now replaced by: + +** New function: SCM scm_create_hook (const char *name, int arity) + +Creates a hook in the same way as make-hook above but also +binds a variable named NAME to it. + +This is the typical way of creating a hook from C code. + +Currently, the variable is created in the "current" module. +This might change when we get the new module system. + +[The behaviour is identical to scm_make_named_hook.] + + + Changes since Guile 1.3: +* Changes to mailing lists + +** Some of the Guile mailing lists have moved to sourceware.cygnus.com. + +See the README file to find current addresses for all the Guile +mailing lists. + +* Changes to the distribution + +** Readline support is no longer included with Guile by default. + +Based on the different license terms of Guile and Readline, we +concluded that Guile should not *by default* cause the linking of +Readline into an application program. Readline support is now offered +as a separate module, which is linked into an application only when +you explicitly specify it. + +Although Guile is GNU software, its distribution terms add a special +exception to the usual GNU General Public License (GPL). Guile's +license includes a clause that allows you to link Guile with non-free +programs. We add this exception so as not to put Guile at a +disadvantage vis-a-vis other extensibility packages that support other +languages. + +In contrast, the GNU Readline library is distributed under the GNU +General Public License pure and simple. This means that you may not +link Readline, even dynamically, into an application unless it is +distributed under a free software license that is compatible the GPL. + +Because of this difference in distribution terms, an application that +can use Guile may not be able to use Readline. Now users will be +explicitly offered two independent decisions about the use of these +two packages. + +You can activate the readline support by issuing + + (use-modules (readline-activator)) + (activate-readline) + +from your ".guile" file, for example. + +* Changes to the stand-alone interpreter + +** All builtins now print as primitives. +Previously builtin procedures not belonging to the fundamental subr +types printed as #>. +Now, they print as #. + +** Backtraces slightly more intelligible. +gsubr-apply and macro transformer application frames no longer appear +in backtraces. + +* Changes to Scheme functions and syntax + +** Guile now correctly handles internal defines by rewriting them into +their equivalent letrec. Previously, internal defines would +incrementally add to the innermost environment, without checking +whether the restrictions specified in RnRS were met. This lead to the +correct behaviour when these restriction actually were met, but didn't +catch all illegal uses. Such an illegal use could lead to crashes of +the Guile interpreter or or other unwanted results. An example of +incorrect internal defines that made Guile behave erratically: + + (let () + (define a 1) + (define (b) a) + (define c (1+ (b))) + (define d 3) + + (b)) + + => 2 + +The problem with this example is that the definition of `c' uses the +value of `b' directly. This confuses the meoization machine of Guile +so that the second call of `b' (this time in a larger environment that +also contains bindings for `c' and `d') refers to the binding of `c' +instead of `a'. You could also make Guile crash with a variation on +this theme: + + (define (foo flag) + (define a 1) + (define (b flag) (if flag a 1)) + (define c (1+ (b flag))) + (define d 3) + + (b #t)) + + (foo #f) + (foo #t) + +From now on, Guile will issue an `Unbound variable: b' error message +for both examples. + +** Hooks + +A hook contains a list of functions which should be called on +particular occasions in an existing program. Hooks are used for +customization. + +A window manager might have a hook before-window-map-hook. The window +manager uses the function run-hooks to call all functions stored in +before-window-map-hook each time a window is mapped. The user can +store functions in the hook using add-hook!. + +In Guile, hooks are first class objects. + +*** New function: make-hook [N_ARGS] + +Return a hook for hook functions which can take N_ARGS arguments. +The default value for N_ARGS is 0. + +(See also scm_make_named_hook below.) + +*** New function: add-hook! HOOK PROC [APPEND_P] + +Put PROC at the beginning of the list of functions stored in HOOK. +If APPEND_P is supplied, and non-false, put PROC at the end instead. + +PROC must be able to take the number of arguments specified when the +hook was created. + +If PROC already exists in HOOK, then remove it first. + +*** New function: remove-hook! HOOK PROC + +Remove PROC from the list of functions in HOOK. + +*** New function: reset-hook! HOOK + +Clear the list of hook functions stored in HOOK. + +*** New function: run-hook HOOK ARG1 ... + +Run all hook functions stored in HOOK with arguments ARG1 ... . +The number of arguments supplied must correspond to the number given +when the hook was created. + +** The function `dynamic-link' now takes optional keyword arguments. + The only keyword argument that is currently defined is `:global + BOOL'. With it, you can control whether the shared library will be + linked in global mode or not. In global mode, the symbols from the + linked library can be used to resolve references from other + dynamically linked libraries. In non-global mode, the linked + library is essentially invisible and can only be accessed via + `dynamic-func', etc. The default is now to link in global mode. + Previously, the default has been non-global mode. + + The `#:global' keyword is only effective on platforms that support + the dlopen family of functions. + +** New function `provided?' + + - Function: provided? FEATURE + Return true iff FEATURE is supported by this installation of + Guile. FEATURE must be a symbol naming a feature; the global + variable `*features*' is a list of available features. + +** Changes to the module (ice-9 expect): + +*** The expect-strings macro now matches `$' in a regular expression + only at a line-break or end-of-file by default. Previously it would + match the end of the string accumulated so far. The old behaviour + can be obtained by setting the variable `expect-strings-exec-flags' + to 0. + +*** The expect-strings macro now uses a variable `expect-strings-exec-flags' + for the regexp-exec flags. If `regexp/noteol' is included, then `$' + in a regular expression will still match before a line-break or + end-of-file. The default is `regexp/noteol'. + +*** The expect-strings macro now uses a variable + `expect-strings-compile-flags' for the flags to be supplied to + `make-regexp'. The default is `regexp/newline', which was previously + hard-coded. + +*** The expect macro now supplies two arguments to a match procedure: + the current accumulated string and a flag to indicate whether + end-of-file has been reached. Previously only the string was supplied. + If end-of-file is reached, the match procedure will be called an + additional time with the same accumulated string as the previous call + but with the flag set. + +** New module (ice-9 format), implementing the Common Lisp `format' function. + +This code, and the documentation for it that appears here, was +borrowed from SLIB, with minor adaptations for Guile. + + - Function: format DESTINATION FORMAT-STRING . ARGUMENTS + An almost complete implementation of Common LISP format description + according to the CL reference book `Common LISP' from Guy L. + Steele, Digital Press. Backward compatible to most of the + available Scheme format implementations. + + Returns `#t', `#f' or a string; has side effect of printing + according to FORMAT-STRING. If DESTINATION is `#t', the output is + to the current output port and `#t' is returned. If DESTINATION + is `#f', a formatted string is returned as the result of the call. + NEW: If DESTINATION is a string, DESTINATION is regarded as the + format string; FORMAT-STRING is then the first argument and the + output is returned as a string. If DESTINATION is a number, the + output is to the current error port if available by the + implementation. Otherwise DESTINATION must be an output port and + `#t' is returned. + + FORMAT-STRING must be a string. In case of a formatting error + format returns `#f' and prints a message on the current output or + error port. Characters are output as if the string were output by + the `display' function with the exception of those prefixed by a + tilde (~). For a detailed description of the FORMAT-STRING syntax + please consult a Common LISP format reference manual. For a test + suite to verify this format implementation load `formatst.scm'. + Please send bug reports to `lutzeb@cs.tu-berlin.de'. + + Note: `format' is not reentrant, i.e. only one `format'-call may + be executed at a time. + + +*** Format Specification (Format version 3.0) + + Please consult a Common LISP format reference manual for a detailed +description of the format string syntax. For a demonstration of the +implemented directives see `formatst.scm'. + + This implementation supports directive parameters and modifiers (`:' +and `@' characters). Multiple parameters must be separated by a comma +(`,'). Parameters can be numerical parameters (positive or negative), +character parameters (prefixed by a quote character (`''), variable +parameters (`v'), number of rest arguments parameter (`#'), empty and +default parameters. Directive characters are case independent. The +general form of a directive is: + +DIRECTIVE ::= ~{DIRECTIVE-PARAMETER,}[:][@]DIRECTIVE-CHARACTER + +DIRECTIVE-PARAMETER ::= [ [-|+]{0-9}+ | 'CHARACTER | v | # ] + +*** Implemented CL Format Control Directives + + Documentation syntax: Uppercase characters represent the +corresponding control directive characters. Lowercase characters +represent control directive parameter descriptions. + +`~A' + Any (print as `display' does). + `~@A' + left pad. + + `~MINCOL,COLINC,MINPAD,PADCHARA' + full padding. + +`~S' + S-expression (print as `write' does). + `~@S' + left pad. + + `~MINCOL,COLINC,MINPAD,PADCHARS' + full padding. + +`~D' + Decimal. + `~@D' + print number sign always. + + `~:D' + print comma separated. + + `~MINCOL,PADCHAR,COMMACHARD' + padding. + +`~X' + Hexadecimal. + `~@X' + print number sign always. + + `~:X' + print comma separated. + + `~MINCOL,PADCHAR,COMMACHARX' + padding. + +`~O' + Octal. + `~@O' + print number sign always. + + `~:O' + print comma separated. + + `~MINCOL,PADCHAR,COMMACHARO' + padding. + +`~B' + Binary. + `~@B' + print number sign always. + + `~:B' + print comma separated. + + `~MINCOL,PADCHAR,COMMACHARB' + padding. + +`~NR' + Radix N. + `~N,MINCOL,PADCHAR,COMMACHARR' + padding. + +`~@R' + print a number as a Roman numeral. + +`~:@R' + print a number as an "old fashioned" Roman numeral. + +`~:R' + print a number as an ordinal English number. + +`~:@R' + print a number as a cardinal English number. + +`~P' + Plural. + `~@P' + prints `y' and `ies'. + + `~:P' + as `~P but jumps 1 argument backward.' + + `~:@P' + as `~@P but jumps 1 argument backward.' + +`~C' + Character. + `~@C' + prints a character as the reader can understand it (i.e. `#\' + prefixing). + + `~:C' + prints a character as emacs does (eg. `^C' for ASCII 03). + +`~F' + Fixed-format floating-point (prints a flonum like MMM.NNN). + `~WIDTH,DIGITS,SCALE,OVERFLOWCHAR,PADCHARF' + `~@F' + If the number is positive a plus sign is printed. + +`~E' + Exponential floating-point (prints a flonum like MMM.NNN`E'EE). + `~WIDTH,DIGITS,EXPONENTDIGITS,SCALE,OVERFLOWCHAR,PADCHAR,EXPONENTCHARE' + `~@E' + If the number is positive a plus sign is printed. + +`~G' + General floating-point (prints a flonum either fixed or + exponential). + `~WIDTH,DIGITS,EXPONENTDIGITS,SCALE,OVERFLOWCHAR,PADCHAR,EXPONENTCHARG' + `~@G' + If the number is positive a plus sign is printed. + +`~$' + Dollars floating-point (prints a flonum in fixed with signs + separated). + `~DIGITS,SCALE,WIDTH,PADCHAR$' + `~@$' + If the number is positive a plus sign is printed. + + `~:@$' + A sign is always printed and appears before the padding. + + `~:$' + The sign appears before the padding. + +`~%' + Newline. + `~N%' + print N newlines. + +`~&' + print newline if not at the beginning of the output line. + `~N&' + prints `~&' and then N-1 newlines. + +`~|' + Page Separator. + `~N|' + print N page separators. + +`~~' + Tilde. + `~N~' + print N tildes. + +`~' + Continuation Line. + `~:' + newline is ignored, white space left. + + `~@' + newline is left, white space ignored. + +`~T' + Tabulation. + `~@T' + relative tabulation. + + `~COLNUM,COLINCT' + full tabulation. + +`~?' + Indirection (expects indirect arguments as a list). + `~@?' + extracts indirect arguments from format arguments. + +`~(STR~)' + Case conversion (converts by `string-downcase'). + `~:(STR~)' + converts by `string-capitalize'. + + `~@(STR~)' + converts by `string-capitalize-first'. + + `~:@(STR~)' + converts by `string-upcase'. + +`~*' + Argument Jumping (jumps 1 argument forward). + `~N*' + jumps N arguments forward. + + `~:*' + jumps 1 argument backward. + + `~N:*' + jumps N arguments backward. + + `~@*' + jumps to the 0th argument. + + `~N@*' + jumps to the Nth argument (beginning from 0) + +`~[STR0~;STR1~;...~;STRN~]' + Conditional Expression (numerical clause conditional). + `~N[' + take argument from N. + + `~@[' + true test conditional. + + `~:[' + if-else-then conditional. + + `~;' + clause separator. + + `~:;' + default clause follows. + +`~{STR~}' + Iteration (args come from the next argument (a list)). + `~N{' + at most N iterations. + + `~:{' + args from next arg (a list of lists). + + `~@{' + args from the rest of arguments. + + `~:@{' + args from the rest args (lists). + +`~^' + Up and out. + `~N^' + aborts if N = 0 + + `~N,M^' + aborts if N = M + + `~N,M,K^' + aborts if N <= M <= K + +*** Not Implemented CL Format Control Directives + +`~:A' + print `#f' as an empty list (see below). + +`~:S' + print `#f' as an empty list (see below). + +`~<~>' + Justification. + +`~:^' + (sorry I don't understand its semantics completely) + +*** Extended, Replaced and Additional Control Directives + +`~MINCOL,PADCHAR,COMMACHAR,COMMAWIDTHD' +`~MINCOL,PADCHAR,COMMACHAR,COMMAWIDTHX' +`~MINCOL,PADCHAR,COMMACHAR,COMMAWIDTHO' +`~MINCOL,PADCHAR,COMMACHAR,COMMAWIDTHB' +`~N,MINCOL,PADCHAR,COMMACHAR,COMMAWIDTHR' + COMMAWIDTH is the number of characters between two comma + characters. + +`~I' + print a R4RS complex number as `~F~@Fi' with passed parameters for + `~F'. + +`~Y' + Pretty print formatting of an argument for scheme code lists. + +`~K' + Same as `~?.' + +`~!' + Flushes the output if format DESTINATION is a port. + +`~_' + Print a `#\space' character + `~N_' + print N `#\space' characters. + +`~/' + Print a `#\tab' character + `~N/' + print N `#\tab' characters. + +`~NC' + Takes N as an integer representation for a character. No arguments + are consumed. N is converted to a character by `integer->char'. N + must be a positive decimal number. + +`~:S' + Print out readproof. Prints out internal objects represented as + `#<...>' as strings `"#<...>"' so that the format output can always + be processed by `read'. + +`~:A' + Print out readproof. Prints out internal objects represented as + `#<...>' as strings `"#<...>"' so that the format output can always + be processed by `read'. + +`~Q' + Prints information and a copyright notice on the format + implementation. + `~:Q' + prints format version. + +`~F, ~E, ~G, ~$' + may also print number strings, i.e. passing a number as a string + and format it accordingly. + +*** Configuration Variables + + The format module exports some configuration variables to suit the +systems and users needs. There should be no modification necessary for +the configuration that comes with Guile. Format detects automatically +if the running scheme system implements floating point numbers and +complex numbers. + +format:symbol-case-conv + Symbols are converted by `symbol->string' so the case type of the + printed symbols is implementation dependent. + `format:symbol-case-conv' is a one arg closure which is either + `#f' (no conversion), `string-upcase', `string-downcase' or + `string-capitalize'. (default `#f') + +format:iobj-case-conv + As FORMAT:SYMBOL-CASE-CONV but applies for the representation of + implementation internal objects. (default `#f') + +format:expch + The character prefixing the exponent value in `~E' printing. + (default `#\E') + +*** Compatibility With Other Format Implementations + +SLIB format 2.x: + See `format.doc'. + +SLIB format 1.4: + Downward compatible except for padding support and `~A', `~S', + `~P', `~X' uppercase printing. SLIB format 1.4 uses C-style + `printf' padding support which is completely replaced by the CL + `format' padding style. + +MIT C-Scheme 7.1: + Downward compatible except for `~', which is not documented + (ignores all characters inside the format string up to a newline + character). (7.1 implements `~a', `~s', ~NEWLINE, `~~', `~%', + numerical and variable parameters and `:/@' modifiers in the CL + sense). + +Elk 1.5/2.0: + Downward compatible except for `~A' and `~S' which print in + uppercase. (Elk implements `~a', `~s', `~~', and `~%' (no + directive parameters or modifiers)). + +Scheme->C 01nov91: + Downward compatible except for an optional destination parameter: + S2C accepts a format call without a destination which returns a + formatted string. This is equivalent to a #f destination in S2C. + (S2C implements `~a', `~s', `~c', `~%', and `~~' (no directive + parameters or modifiers)). + + +** Changes to string-handling functions. + +These functions were added to support the (ice-9 format) module, above. + +*** New function: string-upcase STRING +*** New function: string-downcase STRING + +These are non-destructive versions of the existing string-upcase! and +string-downcase! functions. + +*** New function: string-capitalize! STRING +*** New function: string-capitalize STRING + +These functions convert the first letter of each word in the string to +upper case. Thus: + + (string-capitalize "howdy there") + => "Howdy There" + +As with the other functions, string-capitalize! modifies the string in +place, while string-capitalize returns a modified copy of its argument. + +*** New function: string-ci->symbol STRING + +Return a symbol whose name is STRING, but having the same case as if +the symbol had be read by `read'. + +Guile can be configured to be sensitive or insensitive to case +differences in Scheme identifiers. If Guile is case-insensitive, all +symbols are converted to lower case on input. The `string-ci->symbol' +function returns a symbol whose name in STRING, transformed as Guile +would if STRING were input. + +*** New function: substring-move! STRING1 START END STRING2 START + +Copy the substring of STRING1 from START (inclusive) to END +(exclusive) to STRING2 at START. STRING1 and STRING2 may be the same +string, and the source and destination areas may overlap; in all +cases, the function behaves as if all the characters were copied +simultanously. + +*** Extended functions: substring-move-left! substring-move-right! + +These functions now correctly copy arbitrarily overlapping substrings; +they are both synonyms for substring-move!. + + +** New module (ice-9 getopt-long), with the function `getopt-long'. + +getopt-long is a function for parsing command-line arguments in a +manner consistent with other GNU programs. + +(getopt-long ARGS GRAMMAR) +Parse the arguments ARGS according to the argument list grammar GRAMMAR. + +ARGS should be a list of strings. Its first element should be the +name of the program; subsequent elements should be the arguments +that were passed to the program on the command line. The +`program-arguments' procedure returns a list of this form. + +GRAMMAR is a list of the form: +((OPTION (PROPERTY VALUE) ...) ...) + +Each OPTION should be a symbol. `getopt-long' will accept a +command-line option named `--OPTION'. +Each option can have the following (PROPERTY VALUE) pairs: + + (single-char CHAR) --- Accept `-CHAR' as a single-character + equivalent to `--OPTION'. This is how to specify traditional + Unix-style flags. + (required? BOOL) --- If BOOL is true, the option is required. + getopt-long will raise an error if it is not found in ARGS. + (value BOOL) --- If BOOL is #t, the option accepts a value; if + it is #f, it does not; and if it is the symbol + `optional', the option may appear in ARGS with or + without a value. + (predicate FUNC) --- If the option accepts a value (i.e. you + specified `(value #t)' for this option), then getopt + will apply FUNC to the value, and throw an exception + if it returns #f. FUNC should be a procedure which + accepts a string and returns a boolean value; you may + need to use quasiquotes to get it into GRAMMAR. + +The (PROPERTY VALUE) pairs may occur in any order, but each +property may occur only once. By default, options do not have +single-character equivalents, are not required, and do not take +values. + +In ARGS, single-character options may be combined, in the usual +Unix fashion: ("-x" "-y") is equivalent to ("-xy"). If an option +accepts values, then it must be the last option in the +combination; the value is the next argument. So, for example, using +the following grammar: + ((apples (single-char #\a)) + (blimps (single-char #\b) (value #t)) + (catalexis (single-char #\c) (value #t))) +the following argument lists would be acceptable: + ("-a" "-b" "bang" "-c" "couth") ("bang" and "couth" are the values + for "blimps" and "catalexis") + ("-ab" "bang" "-c" "couth") (same) + ("-ac" "couth" "-b" "bang") (same) + ("-abc" "couth" "bang") (an error, since `-b' is not the + last option in its combination) + +If an option's value is optional, then `getopt-long' decides +whether it has a value by looking at what follows it in ARGS. If +the next element is a string, and it does not appear to be an +option itself, then that string is the option's value. + +The value of a long option can appear as the next element in ARGS, +or it can follow the option name, separated by an `=' character. +Thus, using the same grammar as above, the following argument lists +are equivalent: + ("--apples" "Braeburn" "--blimps" "Goodyear") + ("--apples=Braeburn" "--blimps" "Goodyear") + ("--blimps" "Goodyear" "--apples=Braeburn") + +If the option "--" appears in ARGS, argument parsing stops there; +subsequent arguments are returned as ordinary arguments, even if +they resemble options. So, in the argument list: + ("--apples" "Granny Smith" "--" "--blimp" "Goodyear") +`getopt-long' will recognize the `apples' option as having the +value "Granny Smith", but it will not recognize the `blimp' +option; it will return the strings "--blimp" and "Goodyear" as +ordinary argument strings. + +The `getopt-long' function returns the parsed argument list as an +assocation list, mapping option names --- the symbols from GRAMMAR +--- onto their values, or #t if the option does not accept a value. +Unused options do not appear in the alist. + +All arguments that are not the value of any option are returned +as a list, associated with the empty list. + +`getopt-long' throws an exception if: +- it finds an unrecognized option in ARGS +- a required option is omitted +- an option that requires an argument doesn't get one +- an option that doesn't accept an argument does get one (this can + only happen using the long option `--opt=value' syntax) +- an option predicate fails + +So, for example: + +(define grammar + `((lockfile-dir (required? #t) + (value #t) + (single-char #\k) + (predicate ,file-is-directory?)) + (verbose (required? #f) + (single-char #\v) + (value #f)) + (x-includes (single-char #\x)) + (rnet-server (single-char #\y) + (predicate ,string?)))) + +(getopt-long '("my-prog" "-vk" "/tmp" "foo1" "--x-includes=/usr/include" + "--rnet-server=lamprod" "--" "-fred" "foo2" "foo3") + grammar) +=> ((() "foo1" "-fred" "foo2" "foo3") + (rnet-server . "lamprod") + (x-includes . "/usr/include") + (lockfile-dir . "/tmp") + (verbose . #t)) + +** The (ice-9 getopt-gnu-style) module is obsolete; use (ice-9 getopt-long). + +It will be removed in a few releases. + +** New syntax: lambda* +** New syntax: define* +** New syntax: define*-public +** New syntax: defmacro* +** New syntax: defmacro*-public +Guile now supports optional arguments. + +`lambda*', `define*', `define*-public', `defmacro*' and +`defmacro*-public' are identical to the non-* versions except that +they use an extended type of parameter list that has the following BNF +syntax (parentheses are literal, square brackets indicate grouping, +and `*', `+' and `?' have the usual meaning): + + ext-param-list ::= ( [identifier]* [#&optional [ext-var-decl]+]? + [#&key [ext-var-decl]+ [#&allow-other-keys]?]? + [[#&rest identifier]|[. identifier]]? ) | [identifier] + + ext-var-decl ::= identifier | ( identifier expression ) + +The semantics are best illustrated with the following documentation +and examples for `lambda*': + + lambda* args . body + lambda extended for optional and keyword arguments + + lambda* creates a procedure that takes optional arguments. These + are specified by putting them inside brackets at the end of the + paramater list, but before any dotted rest argument. For example, + (lambda* (a b #&optional c d . e) '()) + creates a procedure with fixed arguments a and b, optional arguments c + and d, and rest argument e. If the optional arguments are omitted + in a call, the variables for them are unbound in the procedure. This + can be checked with the bound? macro. + + lambda* can also take keyword arguments. For example, a procedure + defined like this: + (lambda* (#&key xyzzy larch) '()) + can be called with any of the argument lists (#:xyzzy 11) + (#:larch 13) (#:larch 42 #:xyzzy 19) (). Whichever arguments + are given as keywords are bound to values. + + Optional and keyword arguments can also be given default values + which they take on when they are not present in a call, by giving a + two-item list in place of an optional argument, for example in: + (lambda* (foo #&optional (bar 42) #&key (baz 73)) (list foo bar baz)) + foo is a fixed argument, bar is an optional argument with default + value 42, and baz is a keyword argument with default value 73. + Default value expressions are not evaluated unless they are needed + and until the procedure is called. + + lambda* now supports two more special parameter list keywords. + + lambda*-defined procedures now throw an error by default if a + keyword other than one of those specified is found in the actual + passed arguments. However, specifying #&allow-other-keys + immediately after the kyword argument declarations restores the + previous behavior of ignoring unknown keywords. lambda* also now + guarantees that if the same keyword is passed more than once, the + last one passed is the one that takes effect. For example, + ((lambda* (#&key (heads 0) (tails 0)) (display (list heads tails))) + #:heads 37 #:tails 42 #:heads 99) + would result in (99 47) being displayed. + + #&rest is also now provided as a synonym for the dotted syntax rest + argument. The argument lists (a . b) and (a #&rest b) are equivalent in + all respects to lambda*. This is provided for more similarity to DSSSL, + MIT-Scheme and Kawa among others, as well as for refugees from other + Lisp dialects. + +Further documentation may be found in the optargs.scm file itself. + +The optional argument module also exports the macros `let-optional', +`let-optional*', `let-keywords', `let-keywords*' and `bound?'. These +are not documented here because they may be removed in the future, but +full documentation is still available in optargs.scm. + +** New syntax: and-let* +Guile now supports the `and-let*' form, described in the draft SRFI-2. + +Syntax: (land* ( ...) ...) +Each should have one of the following forms: + ( ) + () + +Each or should be an identifier. Each + should be a valid expression. The should be a +possibly empty sequence of expressions, like the of a +lambda form. + +Semantics: A LAND* expression is evaluated by evaluating the + or of each of the s from +left to right. The value of the first or + that evaluates to a false value is returned; the +remaining s and s are not evaluated. +The forms are evaluated iff all the s and +s evaluate to true values. + +The s and the are evaluated in an environment +binding each of the preceding ( ) +clauses to the value of the . Later bindings +shadow earlier bindings. + +Guile's and-let* macro was contributed by Michael Livshin. + +** New sorting functions + +*** New function: sorted? SEQUENCE LESS? +Returns `#t' when the sequence argument is in non-decreasing order +according to LESS? (that is, there is no adjacent pair `... x y +...' for which `(less? y x)'). + +Returns `#f' when the sequence contains at least one out-of-order +pair. It is an error if the sequence is neither a list nor a +vector. + +*** New function: merge LIST1 LIST2 LESS? +LIST1 and LIST2 are sorted lists. +Returns the sorted list of all elements in LIST1 and LIST2. + +Assume that the elements a and b1 in LIST1 and b2 in LIST2 are "equal" +in the sense that (LESS? x y) --> #f for x, y in {a, b1, b2}, +and that a < b1 in LIST1. Then a < b1 < b2 in the result. +(Here "<" should read "comes before".) + +*** New procedure: merge! LIST1 LIST2 LESS? +Merges two lists, re-using the pairs of LIST1 and LIST2 to build +the result. If the code is compiled, and LESS? constructs no new +pairs, no pairs at all will be allocated. The first pair of the +result will be either the first pair of LIST1 or the first pair of +LIST2. + +*** New function: sort SEQUENCE LESS? +Accepts either a list or a vector, and returns a new sequence +which is sorted. The new sequence is the same type as the input. +Always `(sorted? (sort sequence less?) less?)'. The original +sequence is not altered in any way. The new sequence shares its +elements with the old one; no elements are copied. + +*** New procedure: sort! SEQUENCE LESS +Returns its sorted result in the original boxes. No new storage is +allocated at all. Proper usage: (set! slist (sort! slist <)) + +*** New function: stable-sort SEQUENCE LESS? +Similar to `sort' but stable. That is, if "equal" elements are +ordered a < b in the original sequence, they will have the same order +in the result. + +*** New function: stable-sort! SEQUENCE LESS? +Similar to `sort!' but stable. +Uses temporary storage when sorting vectors. + +*** New functions: sort-list, sort-list! +Added for compatibility with scsh. + +** New built-in random number support + +*** New function: random N [STATE] +Accepts a positive integer or real N and returns a number of the +same type between zero (inclusive) and N (exclusive). The values +returned have a uniform distribution. + +The optional argument STATE must be of the type produced by +`copy-random-state' or `seed->random-state'. It defaults to the value +of the variable `*random-state*'. This object is used to maintain the +state of the pseudo-random-number generator and is altered as a side +effect of the `random' operation. + +*** New variable: *random-state* +Holds a data structure that encodes the internal state of the +random-number generator that `random' uses by default. The nature +of this data structure is implementation-dependent. It may be +printed out and successfully read back in, but may or may not +function correctly as a random-number state object in another +implementation. + +*** New function: copy-random-state [STATE] +Returns a new object of type suitable for use as the value of the +variable `*random-state*' and as a second argument to `random'. +If argument STATE is given, a copy of it is returned. Otherwise a +copy of `*random-state*' is returned. + +*** New function: seed->random-state SEED +Returns a new object of type suitable for use as the value of the +variable `*random-state*' and as a second argument to `random'. +SEED is a string or a number. A new state is generated and +initialized using SEED. + +*** New function: random:uniform [STATE] +Returns an uniformly distributed inexact real random number in the +range between 0 and 1. + +*** New procedure: random:solid-sphere! VECT [STATE] +Fills VECT with inexact real random numbers the sum of whose +squares is less than 1.0. Thinking of VECT as coordinates in +space of dimension N = `(vector-length VECT)', the coordinates are +uniformly distributed within the unit N-shere. The sum of the +squares of the numbers is returned. VECT can be either a vector +or a uniform vector of doubles. + +*** New procedure: random:hollow-sphere! VECT [STATE] +Fills VECT with inexact real random numbers the sum of whose squares +is equal to 1.0. Thinking of VECT as coordinates in space of +dimension n = `(vector-length VECT)', the coordinates are uniformly +distributed over the surface of the unit n-shere. VECT can be either +a vector or a uniform vector of doubles. + +*** New function: random:normal [STATE] +Returns an inexact real in a normal distribution with mean 0 and +standard deviation 1. For a normal distribution with mean M and +standard deviation D use `(+ M (* D (random:normal)))'. + +*** New procedure: random:normal-vector! VECT [STATE] +Fills VECT with inexact real random numbers which are independent and +standard normally distributed (i.e., with mean 0 and variance 1). +VECT can be either a vector or a uniform vector of doubles. + +*** New function: random:exp STATE +Returns an inexact real in an exponential distribution with mean 1. +For an exponential distribution with mean U use (* U (random:exp)). + +** The range of logand, logior, logxor, logtest, and logbit? have changed. + +These functions now operate on numbers in the range of a C unsigned +long. + +These functions used to operate on numbers in the range of a C signed +long; however, this seems inappropriate, because Guile integers don't +overflow. + +** New function: make-guardian +This is an implementation of guardians as described in +R. Kent Dybvig, Carl Bruggeman, and David Eby (1993) "Guardians in a +Generation-Based Garbage Collector" ACM SIGPLAN Conference on +Programming Language Design and Implementation, June 1993 +ftp://ftp.cs.indiana.edu/pub/scheme-repository/doc/pubs/guardians.ps.gz + +** New functions: delq1!, delv1!, delete1! +These procedures behave similar to delq! and friends but delete only +one object if at all. + +** New function: unread-string STRING PORT +Unread STRING to PORT, that is, push it back onto the port so that +next read operation will work on the pushed back characters. + +** unread-char can now be called multiple times +If unread-char is called multiple times, the unread characters will be +read again in last-in first-out order. + +** the procedures uniform-array-read! and uniform-array-write! now +work on any kind of port, not just ports which are open on a file. + +** Now 'l' in a port mode requests line buffering. + +** The procedure truncate-file now works on string ports as well +as file ports. If the size argument is omitted, the current +file position is used. + +** new procedure: seek PORT/FDES OFFSET WHENCE +The arguments are the same as for the old fseek procedure, but it +works on string ports as well as random-access file ports. + +** the fseek procedure now works on string ports, since it has been +redefined using seek. + +** the setvbuf procedure now uses a default size if mode is _IOFBF and +size is not supplied. + +** the newline procedure no longer flushes the port if it's not +line-buffered: previously it did if it was the current output port. + +** open-pipe and close-pipe are no longer primitive procedures, but +an emulation can be obtained using `(use-modules (ice-9 popen))'. + +** the freopen procedure has been removed. + +** new procedure: drain-input PORT +Drains PORT's read buffers (including any pushed-back characters) +and returns the contents as a single string. + +** New function: map-in-order PROC LIST1 LIST2 ... +Version of `map' which guarantees that the procedure is applied to the +lists in serial order. + +** Renamed `serial-array-copy!' and `serial-array-map!' to +`array-copy-in-order!' and `array-map-in-order!'. The old names are +now obsolete and will go away in release 1.5. + +** New syntax: collect BODY1 ... +Version of `begin' which returns a list of the results of the body +forms instead of the result of the last body form. In contrast to +`begin', `collect' allows an empty body. + +** New functions: read-history FILENAME, write-history FILENAME +Read/write command line history from/to file. Returns #t on success +and #f if an error occured. + +** `ls' and `lls' in module (ice-9 ls) now handle no arguments. + +These procedures return a list of definitions available in the specified +argument, a relative module reference. In the case of no argument, +`(current-module)' is now consulted for definitions to return, instead +of simply returning #f, the former behavior. + +** The #/ syntax for lists is no longer supported. + +Earlier versions of Scheme accepted this syntax, but printed a +warning. + +** Guile no longer consults the SCHEME_LOAD_PATH environment variable. + +Instead, you should set GUILE_LOAD_PATH to tell Guile where to find +modules. + * Changes to the gh_ interface ** gh_scm2doubles @@ -18,6 +1412,192 @@ pointer is NULL, a new array is malloced (the old behaviour). New functions. +* Changes to the scm_ interface + +** Function: scm_make_named_hook (char* name, int n_args) + +Creates a hook in the same way as make-hook above but also +binds a variable named NAME to it. + +This is the typical way of creating a hook from C code. + +Currently, the variable is created in the "current" module. This +might change when we get the new module system. + +** The smob interface + +The interface for creating smobs has changed. For documentation, see +data-rep.info (made from guile-core/doc/data-rep.texi). + +*** Deprecated function: SCM scm_newsmob (scm_smobfuns *) + +>>> This function will be removed in 1.3.4. <<< + +It is replaced by: + +*** Function: SCM scm_make_smob_type (const char *name, scm_sizet size) +This function adds a new smob type, named NAME, with instance size +SIZE to the system. The return value is a tag that is used in +creating instances of the type. If SIZE is 0, then no memory will +be allocated when instances of the smob are created, and nothing +will be freed by the default free function. + +*** Function: void scm_set_smob_mark (long tc, SCM (*mark) (SCM)) +This function sets the smob marking procedure for the smob type +specified by the tag TC. TC is the tag returned by +`scm_make_smob_type'. + +*** Function: void scm_set_smob_free (long tc, SCM (*mark) (SCM)) +This function sets the smob freeing procedure for the smob type +specified by the tag TC. TC is the tag returned by +`scm_make_smob_type'. + +*** Function: void scm_set_smob_print (tc, print) + + - Function: void scm_set_smob_print (long tc, + scm_sizet (*print) (SCM, + SCM, + scm_print_state *)) + +This function sets the smob printing procedure for the smob type +specified by the tag TC. TC is the tag returned by +`scm_make_smob_type'. + +*** Function: void scm_set_smob_equalp (long tc, SCM (*equalp) (SCM, SCM)) +This function sets the smob equality-testing predicate for the +smob type specified by the tag TC. TC is the tag returned by +`scm_make_smob_type'. + +*** Macro: void SCM_NEWSMOB (SCM var, long tc, void *data) +Make VALUE contain a smob instance of the type with type code TC and +smob data DATA. VALUE must be previously declared as C type `SCM'. + +*** Macro: fn_returns SCM_RETURN_NEWSMOB (long tc, void *data) +This macro expands to a block of code that creates a smob instance +of the type with type code TC and smob data DATA, and returns that +`SCM' value. It should be the last piece of code in a block. + +** The interfaces for using I/O ports and implementing port types +(ptobs) have changed significantly. The new interface is based on +shared access to buffers and a new set of ptob procedures. + +*** scm_newptob has been removed + +It is replaced by: + +*** Function: SCM scm_make_port_type (type_name, fill_buffer, write_flush) + +- Function: SCM scm_make_port_type (char *type_name, + int (*fill_buffer) (SCM port), + void (*write_flush) (SCM port)); + +Similarly to the new smob interface, there is a set of function +setters by which the user can customize the behaviour of his port +type. See ports.h (scm_set_port_XXX). + +** scm_strport_to_string: New function: creates a new string from +a string port's buffer. + +** Plug in interface for random number generators +The variable `scm_the_rng' in random.c contains a value and three +function pointers which together define the current random number +generator being used by the Scheme level interface and the random +number library functions. + +The user is free to replace the default generator with the generator +of his own choice. + +*** Variable: size_t scm_the_rng.rstate_size +The size of the random state type used by the current RNG +measured in chars. + +*** Function: unsigned long scm_the_rng.random_bits (scm_rstate *STATE) +Given the random STATE, return 32 random bits. + +*** Function: void scm_the_rng.init_rstate (scm_rstate *STATE, chars *S, int N) +Seed random state STATE using string S of length N. + +*** Function: scm_rstate *scm_the_rng.copy_rstate (scm_rstate *STATE) +Given random state STATE, return a malloced copy. + +** Default RNG +The default RNG is the MWC (Multiply With Carry) random number +generator described by George Marsaglia at the Department of +Statistics and Supercomputer Computations Research Institute, The +Florida State University (http://stat.fsu.edu/~geo). + +It uses 64 bits, has a period of 4578426017172946943 (4.6e18), and +passes all tests in the DIEHARD test suite +(http://stat.fsu.edu/~geo/diehard.html). The generation of 32 bits +costs one multiply and one add on platforms which either supports long +longs (gcc does this on most systems) or have 64 bit longs. The cost +is four multiply on other systems but this can be optimized by writing +scm_i_uniform32 in assembler. + +These functions are provided through the scm_the_rng interface for use +by libguile and the application. + +*** Function: unsigned long scm_i_uniform32 (scm_i_rstate *STATE) +Given the random STATE, return 32 random bits. +Don't use this function directly. Instead go through the plugin +interface (see "Plug in interface" above). + +*** Function: void scm_i_init_rstate (scm_i_rstate *STATE, char *SEED, int N) +Initialize STATE using SEED of length N. + +*** Function: scm_i_rstate *scm_i_copy_rstate (scm_i_rstate *STATE) +Return a malloc:ed copy of STATE. This function can easily be re-used +in the interfaces to other RNGs. + +** Random number library functions +These functions use the current RNG through the scm_the_rng interface. +It might be a good idea to use these functions from your C code so +that only one random generator is used by all code in your program. + +The default random state is stored in: + +*** Variable: SCM scm_var_random_state +Contains the vcell of the Scheme variable "*random-state*" which is +used as default state by all random number functions in the Scheme +level interface. + +Example: + + double x = scm_c_uniform01 (SCM_RSTATE (SCM_CDR (scm_var_random_state))); + +*** Function: scm_rstate *scm_c_default_rstate (void) +This is a convenience function which returns the value of +scm_var_random_state. An error message is generated if this value +isn't a random state. + +*** Function: scm_rstate *scm_c_make_rstate (char *SEED, int LENGTH) +Make a new random state from the string SEED of length LENGTH. + +It is generally not a good idea to use multiple random states in a +program. While subsequent random numbers generated from one random +state are guaranteed to be reasonably independent, there is no such +guarantee for numbers generated from different random states. + +*** Macro: unsigned long scm_c_uniform32 (scm_rstate *STATE) +Return 32 random bits. + +*** Function: double scm_c_uniform01 (scm_rstate *STATE) +Return a sample from the uniform(0,1) distribution. + +*** Function: double scm_c_normal01 (scm_rstate *STATE) +Return a sample from the normal(0,1) distribution. + +*** Function: double scm_c_exp1 (scm_rstate *STATE) +Return a sample from the exp(1) distribution. + +*** Function: unsigned long scm_c_random (scm_rstate *STATE, unsigned long M) +Return a sample from the discrete uniform(0,M) distribution. + +*** Function: SCM scm_c_random_bignum (scm_rstate *STATE, SCM M) +Return a sample from the discrete uniform(0,M) distribution. +M must be a bignum object. The returned value may be an INUM. + + Changes in Guile 1.3 (released Monday, October 19, 1998): @@ -263,6 +1843,14 @@ True iff OBJ is a macro object. Like (macro? OBJ), but true only if OBJ is one of the Guile primitive macro transformers, implemented in eval.c rather than Scheme code. +Why do we have this function? +- For symmetry with procedure? and primitive-procedure?, +- to allow custom print procedures to tell whether a macro is + primitive, and display it differently, and +- to allow compilers and user-written evaluators to distinguish + builtin special forms from user-defined ones, which could be + compiled. + *** New function: (macro-type OBJ) Return a value indicating what kind of macro OBJ is. Possible return values are: