                             Language::MuldisD
---------------------------------------------------------------------------

2007-09-23   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.8.1 is released on CPAN as
    Language-MuldisD-0.8.1.tar.gz.

    * From now on, the file version of MuldisD.pm will be kept in sync with
    the distribution version, regardless of whether that file had otherwise
    been changed since the previous release.

    * New file versions are: MuldisD.pm and Core.pod 0.8.1 and Grammar.pod
    0.6.1 and PerlHosted.pod 0.3.1.  The other pre-existing versioned files
    are unchanged.

    * (Core.pod, Grammar.pod, PerlHosted.pod)  Made various minor
    documentation bug-fixes or updates.

    * (Core.pod)  Updated the SYSTEM-DEFINED CORE SCALAR FUNCTIONS sections
    for enumerated types to consolidate the per-value selector function
    documentation for brevity; the functions themselves were unchanged.

    * (Core.pod)  Updated all the system-defined function signatures to
    remove the 'RO:' text by parameters; that text was superfluous because
    all parameters of all functions are always read-only.  The 'UPD:' and
    'RO:' text in system-defined procedure signatures remains, since a
    procedure can have either/both subject-to-update or read-only params.

2007-09-22   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.8.0 is released on CPAN as
    Language-MuldisD-0.8.0.tar.gz.

    * New file versions are: Core.pod 0.8.0 and Basics.pod 0.7.0 and
    Temporal.pod and Spatial.pod 0.5.1 and MuldisD.pm 0.5.0 and SeeAlso.pod
    0.3.2 and PerlHosted.pod 0.3.0.  The other pre-existing versioned files
    are unchanged.

    * (MuldisD.pm, Basics.pod)  Updates to various main/introductory
    documentation.  Changed the NAME of Basics.pod to "10,000 Mile View of
    Muldis D" from "Design document of the Muldis D language" as it isn't
    the intro file anymore (MuldisD.pm is instead).  Moved the large
    PREFACE and DESCRIPTION sections from Basics.pod to MuldisD.pm, then
    did a small amount of editing to them; Basics.pod then gained small
    replacements.  Further minor edits to other sections.

    * (Core.pod, PerlHosted.pod, Temporal.pod, Spatial.pod)  More
    system-defined package consolidation: Empty merged into Universal;
    Database merged into Tuple; (Set|Maybe|Seq|Bag) merged into Relation;
    Quasi(Set|Maybe|Seq|Bag) merged into QuasiRelation.

    * (Basics.pod)  Added indenting to the ENTITY NAMES hierarchy.

    * (Core.pod)  Moved the documentation sections about non-catalog
    specialized subtypes below their counterpart sections on catalog types.

    * (Core.pod)  Renamed the data types Cat.(ShortNameSet|AttrRenameMap)
    to Cat.(SetOfShortName|BiDiShortNameMap); the latter's attributes were
    also renamed.

    * (Core.pod)  Fleshed out the set of catalog data types by adding these
    new ones: Cat.ScalarLiteral, Cat.E_EK, Cat.Expr, Cat.ShortNameMap,
    Cat.SetOfShortNameMap.

    * (SeeAlso.pod)  Reflected that Muldis DB is now LGPL rather than GPL.

2007-09-11   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.7.0 is released on CPAN as
    Language-MuldisD-0.7.0.tar.gz.

    * Removed the file Catalog.pod, after moving its main content into the
    files Basics.pod and Core.pod, and removed any references to
    Catalog.pod in other files.  The CATALOGS documentation section was
    moved into Basics.pod, below ENTITY NAMES.  The TYPE SUMMARY section
    was merged into its counterpart in Core.pod.  The 2 SYSTEM-DEFINED CORE
    CATALOG (|NON-)SCALAR DATA TYPES sections were moved into Core.pod, at
    the end of all the type definitions.

    * New file versions are: Core.pod 0.7.0 and Basics.pod and Grammar.pod
    0.6.0 and Temporal.pod and Spatial.pod 0.5.0 and PerlHosted.pod 0.2.0.
    The other pre-existing versioned files are unchanged.

    * (Basics.pod)  Chopped the 'main' routine kind down so that it is now
    only applicable to a non-hosted Muldis D application; hosted (eg, by
    Perl) Muldis D programs don't have 'main' Muldis D routines.

    * (Basics.pod, Core.pod)  Changed the database type so its attributes
    may now be composed of not only relations, but databases (the leaves of
    this recursion are all relations); the reason for this was to provide a
    more elegant way to represent the common convention of dividing a
    relational database into schemas for better entity management.

    * (Basics.pod)  Started rewrite of the ENTITY NAMES documentation; for
    now there is just the addition of a new namespace hierarchy.  The new
    hierarchy has the following 8 top-level names: cat, sys, app, glo, dep,
    sch, pkg, lex.  The old namespaces map to the new ones as follows:
    sys.cat -> cat.system ; nat.cat -> cat.native ; mnt -> cat.mount ;
    foreign -> cat.foreign ; interp -> cat.interp ; sys.(type|rtn).* ->
    sys.(Core|<extension>).<package>.* ; nat.(data|type|rtn).* ->
    (app|glo.<depot>).* ; lex.* -> lex.* .  The top-level names [dep, sch,
    pkg] are context-sensitive aliases for something under 'app' and/or
    'glo', so entities can tersely and portably refer to their own
    depot|schema|package, sort of like 'lex' (lexical) allows.  Notably,
    the type of entity, data|type|rtn, is no longer included in the long
    name of most entities, and entities of different types now clearly
    share the same namespace, as per is typical with SQL DBMSs where both
    tables and stored procedures are in the same schema object namespaces.

    * (Core.pod, Grammar.pod, PerlHosted.pod, Temporal.pod, Spatial.pod)
    Renamed all the system-defined types and operators to roughly fit into
    the new namespace hierarchy.  The operators saw less drastic changes,
    as roughly speaking, their 'rtn' name component was simply changed to
    'Core' (it would have been different for temporal/spatial operators,
    but none of those were defined yet).  The types saw more drastic
    changes; roughly speaking, all 'type' were renamed to one of
    Core|Temporal|Spatial, and for non-catalog core types, the unique part
    of each name was replaced with 2 instances of itself.  Roughly
    speaking, what used to be a type name now doubles as a type name and a
    package name for both that type and for its operators.  Following this,
    the new system-defined packages were then either consolidated or split
    as appropriate, grouping most similar entities and separating less
    similar ones.  For example, all generic 'Int' types were grouped under
    one package, and the 'Temporal' types were split into several.

    * (Grammar.pod, PerlHosted.pod)  Updated the example user-defined
    entity names so that they roughly fit into the new namespace hierarchy.
    What was nat.type.* is now glo.the_db.*.

2007-09-03   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.6.0 is released on CPAN as
    Language-MuldisD-0.6.0.tar.gz.

    * New file versions are: Core.pod 0.6.0 and Basics.pod 0.5.1 and
    Grammar.pod 0.5.0 and Temporal.pod 0.4.1 and Spatial.pod 0.4.0 and
    Catalog.pod 0.3.1 and PerlHosted.pod 0.1.0.  The other pre-existing
    versioned files are unchanged.

    * (Core.pod, Basics.pod, Catalog.pod, Temporal.pod, Spatial.pod)
    Renamed the union type Ordinal to Ordered, and any types previously
    referred to as being ordinal types are now referred to as being ordered
    types.  This change makes things more correct (and less confusing),
    since actual ordinal types are supposed to be both finite and discrete,
    whereas some Muldis D ordered types are infinite and/or continuous.

    * (Core.pod)  Removed the floating-point numeric types from the core
    again, but that they aren't yet re-added to some language extension;
    they will be later, as per inexact or significant-figure-watching
    numerics in general.  Now the core just contains exact numerics that
    are integers or rationals (and generally speaking it will now be said
    exact types specifically which some common language extensions like
    temporals or spatials are generally built over).  This simplifying
    change was made because it is expected that most general uses of
    numerics in Muldis D program code will not use numbers in the extreme
    ranges that only inexact floats can represent efficiently (eg, 10^308),
    and rather they will likely just have numbers of less than 20-30
    digits, which are easy enough for rationals.

    * (Core.pod)  Updated the Rat|BRat|DRat type definitions slightly.

    * (Core.pod)  Added the URat|PRat types, which are to Rat what
    UInt|PInt are to Int.  Also added (Set|Maybe|Seq|Bag)OfRat types.

    * (Core.pod)  Added new Int operators range|median|mode, updated the
    Int operator 'power', moved the definition of 'abs' upward.

    * (Core.pod)  Added an initial complement of 28 Rat operators, which
    are mostly a superset of analogies to the Int operators (minus
    'remainder'); additions include operators for calculating
    means/averages, logarithms, and rounding.

    * (Grammar.pod, PerlHosted.pod)  Added sections for the Rat|URat|PRat
    types as per for Int|UInt|PInt.

    * (Spatial.pod)  Added an initial hierarchy of 15 spatial types, but
    as yet they lack descriptions.

2007-08-31   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.5.0 is released on CPAN as
    Language-MuldisD-0.5.0.tar.gz.

    * The rational numeric and floating-point numeric data types have been
    promoted to the language core, and so the main content of Num.pod was
    moved into Core.pod, under the TYPE SUMMARY and SYSTEM-DEFINED CORE
    SCALAR DATA TYPES sections; the rest of the file Num.pod was then
    deleted, and any references to it in other files were removed.  The
    promoted data types were also renamed to remove the '.Num'.

    * New file versions are: Basics.pod and Core.pod 0.5.0 and Grammar.pod
    0.4.1.  The other pre-existing versioned files are unchanged.

    * (Basics.pod)  Reorganized the entity namespace 'lex.*' so it no
    longer mirrors the structure of the (global) 'nat.*' namespace.  There
    are no longer any lexically scoped data types or routines or special
    catalog variables; only normal variables can be lexical.

    * (Basics.pod)  Updated the definition of the 'function' routine kind
    so it has no lexical variables, consists of a single expression tree,
    and can only invoke functions; hence a function is now just a named
    expression tree.  Replaced the 'host_gate' routine type with the 'main'
    routine type, as it is conceptually the non-invokable "main program" of
    a Muldis D program.

    * (Core.pod)  Added a bunch of named core data subtypes that exist for
    convenience, such as because they name many core operator parameter
    types.  Added a tree of these to the TYPE SUMMARY section, and added a
    new SYSTEM-DEFINED CORE SPECIALIZED SUBTYPES section.  For example,
    many of these additions are named
    'sys.type.(Set|Maybe|Seq|Bag)Of(Bool|Int|Blob|Text)'.  The pre-existing
    'sys.type.PInt2_36' type was also moved into these sections.

    * (Core.pod)  Rearranged the documentation sections for operators, so
    that they are all grouped first by routine kind and second by the
    mainly applicable data type, rather than the reverse grouping; all
    functions appear first (the vast majority), then all update operators
    (a minority), then all system services (a smaller minority.

    * (Core.pod)  Renamed many 'v' function parameters to 'topic'.

    * (Core.pod)  Updated the 2 int-text mapping function signatures to
    rename any 'Text' to 'NEText'.  Merged and generalized the 4 blob-text
    mapping functions into 2 which lack '_(2|16)' suffixes.  Added
    'maybe_*' variants of the 2 functions 'Int.(quotient|remainder)'.

    * (Core.pod)  Removed the 'Rat' subtype 'RatI' and renamed its sibling
    subtypes to '(B|D)Rat' from 'Rat(B|D)'.

    * (Core.pod)  Replaced the 2 'FloatB(32|64)' data types with the more
    generic 'Float' type, then gave that 2 new subtypes of '(B|D)Float' as
    per the 'Rat' type hierarchy.  The new 'Float' type is an exact numeric
    of unlimited precision as per 'Int' and 'Rat', and it doesn't have any
    special values like a +/- zero distinction, nor infinities, nor NaNs.
    Note that all Muldis D core numeric types are exact and lack special
    values; any numerics that are inexact or have special values will be
    relegated to language extensions; in the core, any precision loss that
    could possibly happen in an operation (eg, from a square-root) is part
    of the defintion of operators, not the data type.

    * (Core.pod)  Replaced the function 'Tuple.extend' with
    'Tuple.product'; the latter is also fleshed out.

    * (Core.pod)  Fleshed out the definitions of these functions:
    'Relation.quotient' (also renamed from 'divide'), 'Relation.restrict',
    'Relation.extend'.  Also added these functions: 'Relation.product'.

    * (Grammar.pod)  Changed the tokens 'Cat(Short|Long)Name' to
    'Cat.(Short|Long)Name' so they match actual type names like the rest of
    Grammar.pod does.

2007-08-12   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.4.1 is released on CPAN as
    Language-MuldisD-0.4.1.tar.gz.

    * New file versions are: PerlHosted.pod 0.0.1.  The other pre-existing
    versioned files are unchanged.

    * (PerlHosted.pod)  This release is an experiment with an alternate
    formatting of the POD list items, in an attempt to make them look more
    like actual lists under the Search CPAN site, rather than paragraphs;
    each "=item Foo" is now spelled "=item *\rFoo".

2007-08-09   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.4.0 is released on CPAN as
    Language-MuldisD-0.4.0.tar.gz.

    * Renamed MuldisD.pod to MuldisD.pm, and added an empty dummy package
    declaration of Language::MuldisD to it, all for the sole purpose of
    helping the CPAN indexer link to this distribution properly; it doesn't
    work when the namespace file is plain pod.  For similar reasons, the
    version number of MuldisD.pm will now always be kept in sync with the
    whole-distribution version number declared in the Makefile.PL.

    * Also renamed Language.pod to Basics.pod.

    * New file versions are: MuldisD.pm and Basics.pod and Core.pod and
    Grammar.pod and Num.pod and Temporal.pod 0.4.0.  The other pre-existing
    versioned files are unchanged.

    * (Basics.pod)  Introduced complete vs parameterized types.

    * (Basics.pod)  Every data type is now named and is referred to by that
    name, the change being that only scalar types used to have names.  This
    said, the actual identities of types haven't changed, so 2
    differently-named declarations of types that aren't scalar and have the
    same structure will still be considered to be the same actual type; the
    names for types that aren't scalars are simply aliases for this
    identity.  This change was made to greatly simplify (and reduce errors
    in) the process of declaring data types, particularly hierarchical
    types, and declaring nonscalar values.

    * (Core.pod)  Added new operators
    Universal.(is_value_of_type|treat|default).

    * (Core.pod)  Renamed each of the operators Universal.(equal|not_equal)
    and Relation.(empty|not_empty) to prepend an "is_".

    * (Core.pod, Num.pod, Temporal.pod)  Updated each of the ordinal data
    types to specify what their minimum and maximum values are, or whether
    said are infinities.

    * (Core.pod)  Redefined the Maybe-returning N-ary functions
    Ordinal.(min|max) with versions that instead try to return that
    functions' identity value when given zero argument values, and
    fails/dies in just specific situations where said identity is
    impossibly or impractically large to handle.  Also added 2 new
    functions Ordinal.maybe_(min|max) that provide the old behaviour.

    * (Core.pod)  Redefined the N-ary functions Blob.(and|or|xor) from
    resulting in Maybes to resulting in identity values on zero inputs.
    Also corrected the Relation.intersection function definition such that
    its identity value is actually the universal relation for its heading,
    not the empty relation; depending how big that is, the function may now
    possibly fail on zero input values.  Also added new function
    Relation.not, which results in its argument subtracted from the
    universal relation for the same heading; this may possibly fail if that
    is too big a value.

    * (Temporal.pod)  Restricted the Temporal.Duration(|OfDays) types to be
    specific to data with time zone offsets, and added 2 more types
    Temporal.Duration(|OfDays)NoTZ to handle the other possibility; the
    idea is that the former should be considered more accurate than the
    latter, as per DateTime vs DateTimeNoTZ.  Also updated all 4 to permit
    negative durations in addition to positive ones.  Also rearranged the
    types to group all the with-timezone and no-timezone together.

    * (Grammar.pod)  Rewrote the representative Concrete Muldis D grammar
    so that it is formatted as an actual compiling (though otherwise
    untested) Perl 6 grammar, rather than the pseudo-LALR grammar.  Also,
    the rewritten grammar is actually complete, unlike the many "todo" gaps
    in the old.  Not that it won't stand to be further improved later.

    * (Grammar.pod)  Added new EXAMPLES documentation section which shows
    actual Concrete Muldis D code fragments.

    * Added new file lib/Language/MuldisD/PerlHosted.pod, which starts at
    version 0.0.0.  This file parallels Grammar.pod, but instead shows what
    arrangement of core Perl data structures make up Perl hosted Abstract
    Muldis D, which is the recommended interchange format between Muldis D
    implementations and Perl applications.  With code examples!  This file
    also stands as a recommendation for a general AST for use by database
    related modules, such as ORMs, to specify database queries with.

2007-07-24   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.3.1 is released on CPAN as
    Language-MuldisD-0.3.1.tar.gz.

    * New file versions are: Language.pod and SeeAlso.pod 0.3.1.  The other
    versioned files are unchanged at 0.3.0.

    * Fixed a bug where both MuldisD.pod and Language.pod had the same
    NAME, which resulted in CPAN indexing problems.

    * Minor fix in SeeAlso.pod.

2007-07-24   Darren Duncan <perl@DarrenDuncan.net>

    * Language::MuldisD version 0.3.0 is released on CPAN as
    Language-MuldisD-0.3.0.tar.gz.

    * What was Muldis-DB at version 0.2.0 and earlier, has been split in 2,
    with the parts to be Language-MuldisD and Muldis-DB, each at version
    0.3.0 and later.  Prior to the split, both the Perl 5 and Perl 6
    versions of Muldis-DB contained identical copies of what became
    Language-MuldisD; after the split, neither Muldis-D had a copy.

    * All versioned files had their version numbers brought up to 0.3.0.

    * This is the first release of the Language-MuldisD distribution, and
    the first release of any distribution to contain Perl 5 modules named
    Language::MuldisD::\w+.

    * The file lib/Language/MuldisD.pod is cloned from part of what used to
    be lib/Muldis/DB.pm, and the file lib/Language/MuldisD/SeeAlso.pod is
    cloned from part of what used to be lib/Muldis/DB/SeeAlso.pod, and
    lib/Language/MuldisD/Language.pod was renamed from
    lib/Muldis/DB/Language.pod, and all other lib/Language/MuldisD/\w+ were
    renamed from lib/Muldis/DB/Language/\w+.

    * Updated Grammar.pod concerning '(Int|Blob):x:y' so that the 'x' is
    now a single character in the same base as the 'y', rather than being a
    possibly multi-character integer in base-10; moreover, the 'x' is now
    equal to the highest value that a character may represent, which in the
    base in question is 1 less than the base number.  So eg, base-2 is now
    specified with an 'x' value of '1', base-10 is a '9', base-16 an 'F',
    etc.  Also, the 'y' part for Int|Blob is no longer quote-delimited.

    * This is the Language-MuldisD-0.3.0 file manifest:

        Changes
        INSTALL
        lib/Language/MuldisD.pod
        lib/Language/MuldisD/Catalog.pod
        lib/Language/MuldisD/Core.pod
        lib/Language/MuldisD/Ext/Num.pod
        lib/Language/MuldisD/Ext/Spatial.pod
        lib/Language/MuldisD/Ext/Temporal.pod
        lib/Language/MuldisD/Grammar.pod
        lib/Language/MuldisD/Language.pod
        lib/Language/MuldisD/SeeAlso.pod
        LICENSE/GPL
        Makefile.PL
        MANIFEST			This list of files
        MANIFEST.SKIP
        META.yml
        README
        t/LMD_00_Compile.t
        TODO

2007-07-22   Darren Duncan <perl@DarrenDuncan.net>

    The next version of the Module List will list the following module:

      modid:       Language::MuldisD
      DSLIP:       cmong
      description: Formal spec of Muldis D relational DBMS lang
      userid:      DUNCAND (Darren Duncan)
      chapterid:   7 (Database_Interfaces)
      enteredby:   ADAMK (Adam Kennedy)
      enteredon:   Mon Jul 23 04:56:26 2007 GMT

    The resulting entry will be:

    Language::
    ::MuldisD    cmong Formal spec of Muldis D relational DBMS lang DUNCAND

2007-07-20   Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::DB version 0.2.0 for Perl 5 is released on CPAN as
    Muldis-DB-0.2.0.tar.gz.  The rest of this Changes entry refers only to
    the portions of it that became part of the Language-MuldisD
    distribution following release 0.2.0.

    * New file versions are: DB.pod and Language.pod and Core.pod and
    Catalog.pod and Grammar.pod and SeeAlso.pod 0.2.0.  Unchanged file
    versions are: Num.pod and Temporal.pod and Spatial.pod 0.1.0.

    * Updated the TRANSACTIONS AND CONCURRENCY section of Language.pod in
    regards to how the scope of explicit transactions is specified, and
    where implicit transactions occur.  Also, Muldis D now no longer has
    language for non-scope-attached transactions, and any concept of
    distinct transaction initiation or termination statements will be
    hoisted to the host language (presumably as methods of ::DBMS objects).

    * Updated Core.pod to add the scalar type 'PInt2_36', and to replace
    the pseudo-type 'Any' with the pseudo-type 'Some.Universal', and added
    'Some.Ordinal'.

    * Updated Grammar.pod concerning integer literals; they can be
    represented with any of base-2 thru base-36 now.

    * Updated Grammar.pod and Core.pod concerning enumerated types, such as
    Bool and Order; individual values are now specified using eg
    [Bool:true] rather than [Bool.True], which then makes them more like
    literals of other simple types, and less like data type names.

    * Updated Core.pod to add definitions for the generic operators common
    to all ordinal types: compare, reverse_compare, is_increase,
    is_decrease, min, max.  Added 'reverse' operator for the Order type.
    Added or replaced a bunch of operators for the Int|Blob|Text types.
    Other small changes.

    * Updated Core.pod to add an initial complement of common tuple and
    relation operators (such as project, join, union), perhaps most of
    them.  These are a large part of what makes Muldis D a relational
    language at all.

    * Updated Catalog.pod to add new core data types: Cat.ShortNameSet,
    Cat.AttrRenameMap.

2007-07-11   Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::DB version 0.1.0 for Perl 5 is released on CPAN as
    Muldis-DB-0.1.0.tar.gz.  The rest of this Changes entry refers only to
    the portions of it that became part of the Language-MuldisD
    distribution following release 0.2.0.

    * This is a major release that focuses on overhauling or defining part
    of the Muldis D meta-model / system catalog, which is essential for
    supporting any user-defined DBMS entities, that is, for doing anything
    remotely useful.  Said overhaul is expected to be staged over 3-4
    consecutive releases, of which the current one is essentially just
    updating documentation; not much code was changed by this release.

    * As of this release, all pod-only files now also have version numbers,
    shown in the VERSION docs by NAME, like code-containing modules do; the
    initial version numbers are all 0.1.0.

    * Muldis D now has 2 representation formats (Concrete Muldis D,
    Abstract Muldis D) rather than 3 (relations, ASTs, strings).

    * Rearranged any relevant docs so that the most important core scalar
    types are now in the order [Bool, Int, Blob, Text] and the relation
    type factory Maybe now appears after Set.

    * Muldis D now has a new scalar data type, "Order", which is an
    enumeration (like "Bool" is) of 3 values: [Increase, Same, Decrease];
    it is the result type of any binary comparison operator that underlies
    the likes of less|greater-than or min|max or sorting operations.

    * Muldis D now has the new scalar types "Cat.ShortName" and
    "Cat.LongName", which replace the also removed "Cat.EntityName" and its
    (as yet unused) system-defined subtypes.

    * Split up Language.pod 6 ways, into itself and
    Language/(Core|Catalog).pod and
    Language/Ext/(Num|Temporal|Spatial).pod.  For the most part, the only
    initial content of the 5 new files are corresponding portions of what
    used to be the SYSTEM-DEFINED DATA TYPES and (actually empty)
    SYSTEM-DEFINED ROUTINES main documentation sections of Language.pod,
    but that the CATALOGS main section was also moved to Catalog.pod;
    Language.pod retained all the other documentation sections that it
    previously had.  (Language.pod retained about 75% of its previous
    content; about 25% was moved out.)

    * Further updated the 5 language files with type definitions, to update
    some definitions, and also to add a small TYPE SUMMARY main doc section
    to each file.

    * Updated Core.pod to add several main doc sections that have an
    initial complement of system-defined routines.  In particular, the
    equal|not_equal|assign routines that all types have are now defined,
    and all the common boolean and integer operators were added, and some
    converter routines such as int-from-text et al, were all added.  Many
    other operator definitions are pending, especially the relational ones.

    * Added new file lib/Muldis/DB/Language/Grammar.pod, which describes
    Concrete Muldis D details that aren't applicable to Abstract Muldis D.

2007-06-29   Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::DB version 0.0.1 for Perl 5 is released on CPAN as
    Muldis-DB-0.0.1.tar.gz.  The rest of this Changes entry refers only to
    the portions of it that became part of the Language-MuldisD
    distribution following release 0.2.0.

    * New file versions (not marked though) are: Language.pod 0.0.1.

    * The primary purpose of this release is to re-license the Muldis D
    specification under actual free software licenses, specifically version
    3 of the GPL family of licenses, which the Free Software Foundation
    formally published on 2007 June 29th.  By contrast, the previous Muldis
    D releases were under an expiring proprietary license, with just the
    promise of a free re-license to come.  Accordingly, the file
    LICENSE/GPL was added to this distro, which contains the text of the
    GPL version 3.0.

    * This release also includes a collection of small documentation
    updates and fixes, such as the following:  We now use the official
    typography for the names 'TTM' and 'D' and such.  Added a DOCUMENTATION
    READING ORDER section to the README file.

2007-06-20   Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::DB version 0.0.0 for Perl 5 is released on CPAN as
    Muldis-DB-0.0.0.tar.gz.  The rest of this Changes entry refers only to
    the portions of it that became part of the Language-MuldisD
    distribution following release 0.2.0.

    * Initial file versions (not marked though) are: Language.pod 0.0.0.

    * As of this release, the Muldis D specification is officially in
    pre-alpha development status.  A lot of documentation is present, but a
    lot isn't.  What is mostly done is the higher level documentation.
    What is mostly undone is documentation of the API details.  What is
    already present should be sufficient to begin study of Muldis D such
    that it can actually be put to use within the next few weeks or months
    as Muldis D is fleshed out.  Also, it should be possible now to start
    writing code that implements it or uses said.
