HELP PMLNEWS

A chronological summary of changes to the Poplog Standard ML subsystem.

See also PML HELP * BUGS for recent bug fixes.

Anybody still using PML Version 1.3 should refer to PML HELP * VERSION2
for notes on upgrading to Version 2.0 or later.


         CONTENTS - (Use <ENTER> g to access required sections)

  1   Changes Since Poplog Version 14.5

  2   Previous Changes


-----------------------------------------------------------------------
1  Changes Since Poplog Version 14.5
-----------------------------------------------------------------------

13/12/94 (Robert Duncan)
--- A new function call tracer allows you to observe the arguments and
    results of function calls during program execution. To use the
    tracer, you must first compile your program in a special debug mode.
    You can then use the new trace and untrace commands to select
    particular functions for tracing. Each call of a traced function
    displays its actual arguments and results, as in this call to
    length:

        length([1,2,3]);
        [ 1]> length [1, 2, 3]
        [ 2]> length [2, 3]
        [ 3]> length [3]
        [ 4]> length []
        [ 4]< length 0
        [ 3]< length 1
        [ 2]< length 2
        [ 1]< length 3
        val it = 3 : int

    Full details are in HELP * TRACE.

24/11/94 (Robert Duncan)
--- ML-Lex and ML-Yacc have been installed in the *CONTRIB directory.
    See HELP * MLLEX, * MLYACC.

22/11/94 (Robert Duncan)
--- A new library module NJCompat can help in porting programs written
    for Standard ML of New Jersey. See HELP * NJCOMPAT. Also, the
    abstraction reserved word used by SML/NJ is now recognised by PML,
    although the form is not implemented: abstraction is treated as a
    synonym for structure.

16/11/94 (Robert Duncan)
--- The Array module (see HELP * ARRAY) has been modified such that the
    array type constructor it defines now admits equality. Equality is
    defined on arrays as address equality, i.e., two arrays are equal if
    and only if they occupy the same region of memory. Obviously, if two
    arrays are equal then their contents must be equal, but the converse
    does not hold. This is analogous to the definition of equality on
    references, and it has the same property, namely that the type

        ty array

    is always an equality type regardless of whether ty is itself an
    equality type.

--- Arrays and vectors can now be created and accessed from Pop-11: see
    HELP * MLINPOP.

--- The syntax rules for the use of the semicolon at top-level have
    been relaxed. Specifically, you can now mix all kinds of module
    declarations -- functor, signature and structure -- without
    separating them with ";". So the following will now compile where
    previously it would not:

        signature S = sig ... end
        functor F():S = struct ... end
        structure S:S = F()

    You must still use semicolons to separate declarations from commands
    and top-level expressions.

26/10/94 (Robert Duncan)
--- Changes in error reporting. In particular, type errors now give
    considerably more information about the context of the error and the
    reason for it. For example:

      - 2.4 / 5;

        Error: in expression
            2.4 / 5
        Cannot apply function
            op / : real * real -> real
        to argument
            (2.4, 5) : real * int

--- The Ved command <ENTER> f can now be used to locate the binding
    occurrence of an identifier within the current sourcefile. For
    example, doing:

        <ENTER> f sort

    will move the cursor to the start of the definition of the function
    sort (if it's defined within the file). By default, the argument is
    assumed to be a function name, i.e. bound in a fun declaration. You
    can look for a different class of identifier by prefixing the name
    with one of the keywords

        val
        type
        exception
        structure
        signature
        functor

    So doing:

        <ENTER> f type graph

    would locate the definition of the type constructor graph. See
    HELP * MLVED.


-----------------------------------------------------------------------
2  Previous Changes
-----------------------------------------------------------------------

28/06/91 (Simon Nichols)
--- A modest improvement in code size and runtime speed has been
    effected by optimising the treatment of variables which are
    referenced only once.

14/06/91 (Robert Duncan)
--- The Edinburgh Standard ML Library (Revision 1.16) installed in the
    contrib directory. See HELP * SMLLIB.

28/05/91 (Robert Duncan)
--- New library module OS installed which provides an interface to the
    host operating system. See HELP * OS.

18/03/91 (Robert Duncan)
--- A new function

        val Compile.localise (r : 'a ref) : 'a ref

    localises the value of a reference for the duration of the current
    invocation of the compiler. Whenever the compilation terminates,
    even if caused by an error, the previous value of the reference is
    restored. This is especially useful for localising the effects of
    changes to compiler flags. For example, the line

        Compile.localise Compile.warnings := false;

    placed at the start of a file will disable warning messages for that
    file only. See HELP *localise.

18/03/91 (Robert Duncan)
--- The compiler's closure rules are now turned off by default; this is
    to improve compatibility with other Standard ML systems. Since this
    implies a relaxation of checking, it's unlikely that any existing
    programs will break. In the event of problems, or if the stricter
    regime is preferred, you can restore the previous situation by
    putting in your "init.ml" file the line:

        Compile.closure_rules := true;

    See HELP *closure_rules.

01/03/91 (Robert Duncan)
--- Arguments to commands may now be enclosed within string quotes ("").
    This is to provide a greater conformity in the syntax for commands
    and functions, as in:

        cd "example";

    It also means that spaces and semicolons can be included in
    arguments, e.g:

        ved "lib.ml;2"

--- A new command

        bye

    exits from PML. See HELP * COMMANDS.

11/02/91 (Robert Duncan)
--- The format and content of error messages has been changed to make
    them clearer and more intelligible. Most noticeably, messages are
    now largely in lower case.

--- Occurrences of "non-generic" (or "free") type variables in type
    error messages are now displayed as

        'A, 'B, 'C, ... etc.

    instead of the previous

        'ty1, 'ty2, 'ty3, ...

04/02/91 (Robert Duncan)
--- Changes in the interpretation of identifier status (determining
    whether a particular identifier denotes a variable, constructor,
    exception etc.) have resolved various anomalies and errors. For
    example, it's now possible to rebind an exception as a value
    constructor, which was previously illegal.

--- The reserved word "=" is now allowed to stand for the equality
    predicate in more cases than previously, specifically:

        - as a secondary component in a long identifier:

            StdValues.=

        - in a fixity directive:

            nonfix =

        - in a value description:

            val = : ''a * ''a -> bool

21/01/91 (Robert Duncan)
--- A bug in the code generated for exception handlers which prevented
    them from being properly tail recursive is now fixed. A function
    such as:

        fun loop() = ... handle e => (...; loop())

    will now run in constant space.

14/01/91 (Robert Duncan)
--- Source code for programs from the book ML for the Working Programmer
    by Lawrence C. Paulson has been installed in the Poplog contrib tree
    (for user-contributed software). See HELP * WORKING_PROGRAMMER.

10/12/90 (Robert Duncan)
--- The library module Array has been substantially revised, in the
    light of discussions held among the SML user community. Array
    operations are now divided between two structures:

        structure Array : Array

    defines the array type and a minimal set of functions for creating
    and accessing arrays. This is a standard module which should be
    supported by all Standard ML compilers. See HELP * ARRAY.

        structure ExtendedArray : ExtendedArray

    defines some additional, non-standard functions on arrays. See
    HELP * EXTENDED_ARRAY.

    There are two major changes: indexes for arrays now start at 0, so
    that legal indexes for the object

        array(n, x)

    lie in the range

        0 <= i < n

    Also, the function *sub (for accessing an array) is no longer infix
    by default. There have also been several name changes, although all
    the previous functionality is still available. See the help files
    for details.

--- A new Vector structure, similar to Array, provides constant-time
    access without updating. See HELP * VECTOR.

28/11/90 (Robert Duncan)
--- The Edinburgh Standard ML program Library (Version 0.1 beta) has
    been installed in the Poplog contrib tree (for user-contributed
    software). See HELP * CONTRIB.

30/10/90 (Robert Duncan)
--- The identifier *before is now infix by default. To reverse this
    change, add to your "init.ml" file the line:

        nonfix before;

09/10/90 (Robert Duncan)
--- An experimental exception traceback facility has been added: see
    HELP * traceback.

13/09/90 (Robert Duncan)
--- New function

        val sort : ('a * 'a -> bool) -> 'a list -> 'a list

    added to the List module. See HELP * sort.

10/08/90 (Robert Duncan)
--- New number libraries:

        HELP * RATIO
            Rational numbers
        HELP * COMPLEX
            Complex numbers
        HELP * FASTINT
            Fast, non-checking operations on small integers

09/08/90 (Robert Duncan)
--- A new exception Overflow has been introduced which is raised on all
    occurrences of real arithmetic overflow regardless of the operation
    in progress. Many of the distinct arithmetic exceptions required by
    the Definition -- Sum, Diff, Prod, etc. -- have now been made
    synonyms for Overflow. See HELP * Overflow.


--- C.all/pml/help/changes
--- Copyright University of Sussex 1994. All rights reserved.
