                                 Muldis::D
---------------------------------------------------------------------------

2009-05-19  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.73.0 is released on CPAN as
    Muldis-D-0.73.0.tar.gz.

    * (Types_Catalog.pod, Basics.pod, Types.pod, Text.pod, PTMD_STD.pod,
    HDMD_Perl[6|5]_STD.pod)  Updated the "UCPString" type definition (and
    consequently "Text"/etc) so it excludes the special/abnormal/UTF-16
    "surrogate" codepoints between F;D800 and F;DFFF inclusive, and so now
    just includes the complementary ranges within zero and 0x10FFFF
    inclusive.  Also updated any references to "codepoint" in the language
    spec to specify "abstract codepoint" instead, which is more specific.

    * (Types_Catalog.pod)  Renamed the infinite number of "String.*" types
    so that their unqualified names are just spelled out with sequences
    delimited base-10 integer literals rather than with essentially their
    own native values.  Then updated the "Name" type so it now has the same
    character repertoire as "Text" or "Comment"; its sole possrep attribute
    is now a "UCPString" rather than a "String".

    * (Types_Catalog.pod)  Updated the "Name" and "Comment" types so that
    now each is a thin wrapper over the "Text" type rather than over the
    "UCPString" type.  The main consequence of this change is that now all
    system-defined character string types can be used with the operators
    defined for the "Text" type, and also that any future enhancements to
    the "Text" type itself or its operators are also shared by the other
    character string types.

    * (Basics.pod, Types.pod, Text.pod, PTMD_STD.pod)  Updated the Muldis D
    concept of a character string, which used to be simply a sequence of
    Unicode codepoints, so it is both more restricted and more abstract at
    the same time.  Updated the "Text" type so that its codepoint string
    must now be in canonical decomposed normal form (NFD); a consequence of
    this is that two character strings will now generally match at the
    grapheme abstraction level, which is more user friendly than the old
    behaviour, especially since the actual codepoints used to build a
    grapheme is typically an implementation detail they don't control.  Now
    also the possrep of "Text" was renamed from "codepoints" to
    "nfd_codepoints".  In Text.pod, renamed the "length_in_codepoints"
    function to "length_in_nfd_codepoints" and deleted the 2 functions
    "folded_to_NF[C|D]" which are now meaningless.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Within the main pod section
    "COLLECTION VALUE SELECTORS", added new pod sub-section "Rational
    Rounding Rule Selectors", which declares syntax specific to selecting
    "sys.std.Core.Type.Cat.RatRoundRule" values, which may be used a lot in
    value expressions involving rational numbers.  In PTMD_STD, this
    section introduced these new 2 main ("value") node kinds:
    "RatRoundRule[|_payload]".

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Within the main pod section
    "FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS", normalized the
    basic format of "func_invo_alt_syntax"/"op" nodes.  In PTMD_STD this
    was just a documentation/concept update, while in both Perl-STD this
    was an actual design change.  In both Perl-STD, all kinds of op nodes
    have exactly 3-4 ordered elements rather than 3-N; previously the 3rd+
    elements were the op args, and now the 3rd element is an array of
    main/mandatory op args and the 4th is a hash of extra/optional ones;
    the dyadic op code examples were updated as approp; N-adic were unch.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Refactored the grammar by
    splitting the 2 pod sub-sections ["Infix N-adic Reduction Operators",
    "Infix Homogenous Dyadic Operators"] into the 4 pod sub-sections
    ["Simple [C|Non-c]ommutative N-adic Infix Reduction Operators", "Simple
    [C|Non-c]ommutative Dyadic Infix Operators"].  Correspondingly, in
    PTMD_STD, the 2 main node kinds "infix_[reduce|h_dyadic]_op_invo" were
    split into the 4 main node kinds
    "[|non]comm_[infix_reduce|dyadic_infix]_op_invo".

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Added 2 more
    function-specific concrete syntaxes to the existing pod sub-section
    "Simple Commutative Dyadic Infix Operators".

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Within the main pod section
    "FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS", added 3 more pod
    sub-sections ["Simple Monadic P[re|ost]fix Operators", "Rational
    Operators That Do Rounding"].  The additions provide 11 more
    function-specific concrete syntaxes.  In PTMD_STD, these sections
    introduced these new 3 main node kinds: "monadic_p[re|ost]fix_op_invo",
    "rat_op_invo_with_round".

    * (BBEdit_LM_Muldis_D.plist)  Updates corresp to recent spec changes.

2009-05-15  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.72.0 is released on CPAN as
    Muldis-D-0.72.0.tar.gz.

    * (PTMD_STD.pod)  Corrected the "[|d_]utc_duration_body" tokens so that
    their 6th (rational) element was optional and had a leading comma.

    * (Types_Catalog.pod, PTMD_STD.pod)  Added a comment paragraph to each
    of the "BagSelExprNodeSet" type definition and the "Bag" grammar node
    definition, to clarify that any explicit "count" values a programmer
    writes are compile-time constants, and if they want "count" values to
    be determinable at runtime, they'll have to use a "RelSelExprNodeSet"
    tuple or "Relation" node to specify the q/bag value selection instead.

    * (PTMD_STD.pod)  Reverse-refactored the grammar so that minor
    separator or delimiter tokens were merged into the places that used
    them, generally making the latter less verbose and easier to understand
    at a glance; arguably the extra semantic information gotten from naming
    these tokens was trivial and didn't need to be spelled out.  The
    eliminated distinct tokens were these 13: "term_sep",
    "value_[node|payload]_elem_sep", "segment_sep", "name_chain_elem_sep",
    "[list|pair]_elem_sep", "[[|non]ord|param]_list_[open|close]".  Then
    following those changes, cleaned up any superfluous "\w+".

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Added new main pod section
    "FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS" with the initial 2
    pod sub-sections ["Infix N-adic Reduction Operators", "Infix Homogenous
    Dyadic Operators"].  In PTMD_STD, these sections introduced these new 3
    main node kinds: "func_invo_alt_syntax", "infix_reduce_op_invo",
    "infix_h_dyadic_op_invo".  The additions provide an initial complement
    of 23 special concrete syntaxes for invoking some functions, for
    example allowing one to invoke the typical mathematical operators using
    infix notation rather than the normal prefix notation of "func_invo".

    * (HDMD_Perl5_STD.pod, BBEdit_LM_Muldis_D.plist)  Other minor updates.

2009-05-14  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.71.0 is released on CPAN as
    Muldis-D-0.71.0.tar.gz.

    * (Basics.pod)  Corrected the "Referencing Data Types" pod subsection
    of "ENTITY NAMES" so that the "type.type." namespace prefix only is
    used to reference attributes of directly referenceable types, and it is
    not used to simply reference a directly referenceable type.  Also
    clarified that the "type." top level namespace *is* used when
    "tuple_from."/etc or "array_of."/etc are used and
    "[var|type|func_result|param]." is not used.

    * (PTMD_STD.pod)  Updated the "NameChain" node payload definition to
    add a third special case where the chain may be abbreviated, which is
    that with "type." chain prefixes, the prefix-leading "type" element may
    be omitted when the chain prefix contains a "tuple_from."/etc or
    "array_of."/etc, since the latter's presence keeps things unambiguous.

    * (Integer.pod)  Updated the "sys.std.Integer.power" function so that
    zero raised to the power of zero is no longer considered a failure but
    rather results in 1, which seems reasonable given that this specific
    function strictly has no numeric continuity (unlike "Rational.power")
    and that this is by far the most common practice in both pure integer
    math contexts and computer languages, including SQL.

    * (Rational.pod)  Updated the "sys.std.Rational.power" function to add
    a "round_rule" parameter; this is a correction since it was previously
    assumed that "power" with rational arguments would have a rational
    result in the general case, which was wrong (take 2 ^ 0.5 for example).

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Updated the main pod section
    "GENERIC VALUE EXPRESSIONS" with the new main node kind "named_expr",
    which lets you give an explicit name to an "expr" node (that can then
    be referenced with an "expr_name" node).

    * (PTMD_STD.pod)  Partially reformatted the grammar with a new syntax
    that is a hybrid between the Perl 6 rules used before and EBNF with
    further changes.  There are exactly 2 main differences from before. The
    first is that all explicit capturing syntax is gone (the parenthesis
    that is).  The second is that a token is now declared as "<footok> ::=
    ..." rather than "token footok { ... }"; the actual ... is unchanged
    save for the previous sentence.  Also rewrote the second half of the
    "GENERAL STRUCTURE" main pod section (format explanation) accordingly,
    also adding more information on how tokens and capture nodes relate.

2009-05-11  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.70.0 is released on CPAN as
    Muldis-D-0.70.0.tar.gz.

    * This release features large new additions to all 3 bundled dialects,
    such that the entire generic concrete syntax for Muldis D value
    expressions is now specified, and not just the syntax for literals.

    * (Types_Catalog.pod)  Fixed a fossil in the description of the
    "namespaces" attribute of the "System" catalog type: "DeclNameChain"
    value literals no longer have leading and trailing periods.

    * (Routines.pod, Routines_Catalog.pod, Integer.pod, Blob.pod, Text.pod,
    Rational.pod, QArray.pod, Temporal.pod)  Updated all the simpler
    system-defined (N-ary) reduction operators, specifically those
    functions that can succeed in all cases with zero input values, so to
    make their only parameter optional; when such a function is invoked
    with no explicit argument, the result is the same as if it were given
    an explicit empty list argument, and so the result of an invocation
    with no argument is the function's identity value.  The 15 functions so
    updated are: "sys.std.Core.Bool.[and|or|xor]",
    "sys.std.Core.QRelation.[join|product]",
    "sys.std.Core.Cat.Order.reduction",
    "sys.std.[Integer|Rational].[sum|product]",
    "sys.std.[Blob|Text|QArray].catenation",
    "sys.std.Temporal.[|UTC]Duration.sum".

    * (Routines.pod)  Added new function
    "sys.std.Core.Universal.is_not_value_of_type" which is a simple
    complement to the existing "is_value_of_type" function.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Added new main pod section
    "GENERIC VALUE EXPRESSIONS" with the initial 4 pod sub-sections
    ["Generic Function Invocation Expressions", "Generic If-Else
    Expressions", "Generic Given-When-Default Expressions", "Library Entity
    Reference Selector"].  In PTMD_STD, these sections introduced these new
    6 main node kinds: "expr", "expr_name", "func_invo_expr",
    "if_else_expr", "given_when_def_expr", "lib_entity_ref_selector".  The
    additions round out the entire generic concrete syntax for Muldis D
    value expressions, when added to all the kinds of "value" nodes that
    the grammars had before.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Other minor updates.

2009-05-08  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.69.0 is released on CPAN as
    Muldis-D-0.69.0.tar.gz.

    * (Types_Catalog.pod)  Fixed a fossil in the description of the
    "namespaces" attribute of the "System" catalog type where mention of
    the 2 namespaces "tpc" and "tpc.cat" had been omitted.

    * (PTMD_STD.pod)  Corrected the "bootloader" grammar token, which
    didn't have whitespace between its elements; added new token
    "term_sep", which indicates mandatory whitespace.

    * (PTMD_STD.pod)  Updated the "Value Literal Common Elements" pod
    subsection to add a description on how a C<type_name> element of a
    C<value> node is interpreted depending on context.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Took what used to be the
    "auto_unabbrev_std_names" pragma and made it into standard behaviour,
    also eliminating that pragma in the process.  Updated the "NameChain"
    node payload definition so it now may have as few as 1 element rather
    than as few as 2.  As per the old pragma, now any name chains for
    invoking system-defined types and routines can be written typically as
    its unqualified short name, eg "Int" for "sys.std.Core.Type.Int", and
    it would be unambiguously expanded by the parser.  The Muldis D spec
    itself had been using such abbreviations for a long time, but now that
    practice has been formally specified.  As a new further expansion of
    this feature, now any name chains for invoking named value expressions
    or variables etc can have any leading "lex." element omitted, and it
    would be unambiguously re-added by the parser.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Eliminated a fossil which is
    the "auto_chains_from_names" pragma; this hasn't actually been useful
    for awhile now.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  Eliminated the last pragma,
    "auto_add_attrs", since its usefulness is now questionable; however,
    that functionality might return in the future, maybe with alterations,
    or perhaps better as a feature in the system catalog itself.

    * (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)  A bit of grammar refactoring:
    Split "Tuple and Database Selectors" 2 ways into "Tuple Selectors" and
    "Database Selectors".  Split the 2 "QTuple[|_payload]" nodes into
    themselves and the 2 new "Database[|_payload]".

    * (Basics.pod, [Types|Routines]_[|Catalog].pod, QBag.pod, SeeAlso.pod,
    INSTALL)  Corrected several instances of repeated word typos.

    * (PTMD_STD.pod)  Other minor fixes.

2009-05-06  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.68.0 is released on CPAN as
    Muldis-D-0.68.0.tar.gz.

    * This release features the renaming of all the bundled Muldis D
    dialects/grammars from "_Tiny" to "_STD", which seems more appropriate
    now.  Renamed the 3 files "[PTMD|HDMD_Perl[6|5]]_Tiny.pod" to
    "[PTMD|HDMD_Perl[6|5]]_STD.pod".  Updated any references in these other
    files to reflect the new dialect names: README, D.pm, Basics.pod,
    Types.pod, BBEdit_LM_Muldis_D.plist.

    * (Basics.pod, HDMD_Perl5_STD.pod)  Other minor fixes.

2009-05-04  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.67.0 is released on CPAN as
    Muldis-D-0.67.0.tar.gz.

    * (PTMD_Tiny.pod)  Simplified the grammar so it doesn't do work that
    could just as easily be, or would better be, done after the early
    parsing stage that the grammar describes.  Simplified the 2
    "[UTC|Float]Instant_payload" tokens so they simply alias the
    "UTCDuration_payload"; all 3 now simply look for a sequence of 5
    integers followed by a rational, rather than restricting to integers
    that are specifically non-negative or positive.  Then deleted the 6
    now-unused tokens "[[|d_][nn[int|rat]|utc_instant]_body".

    * (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod)  Updated the grammar for
    language name literals to make the 5th/extensions part optional; you no
    longer have to have an explicit empty list when you're using defaults.

    * (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod)  Updated the grammar for
    "RatRoundMeth" value literals so that it may now have a "type_name"
    element like most value literals (all but "Bool" and "Order").

    * (Types.pod)  In Types.pod, deleted the singleton data type "Nothing"
    as it no longer seems useful to have singleton data types that are not
    root types.  Then updated the description of the "Maybe" data type to
    say that its sole value with zero elements is now also known by the
    special name "Maybe:nothing", aka "nothing".

    * (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod)  Updated all Muldis D
    dialects so to merge the 2 value node kinds of "Single" and "Nothing"
    into the single new kind "Maybe", which provides the new terse means to
    select "Maybe" values.  The syntax for "Maybe" is the same as "Single"
    was, save for the keyword "Maybe" replacing "Single", and also that new
    syntax is added for selecting the value "nothing".  In PTMD_Tiny, the
    syntax "Maybe:{...}" means a "Single" value and "Maybe:nothing" means
    the "nothing" value; also the latter may now be spelled with an omitted
    "value_kind" like "Int" nodes et al, as just "nothing".  In
    HDMD_Perl[6|5]_Tiny, a Perl defined payload indicates a "Single" value,
    while the Perl undef value indicates the "nothing" value; this change
    should make dynamic generation of "Maybe" literals easier considering
    that Perl users tend to equate the Perl concept of undefined with the
    SQL concept of NULL, meaning nothing more than "not a normal value".

    * (Basics.pod, Types_Catalog.pod, Routines_Catalog.pod, QRelation.pod,
    QSet.pod, Temporal.pod)  Updated any other files having references to
    "Nothing" so they reference "nothing" instead.

    * (Types.pod, Basics.pod, Types_Catalog.pod, QRelation.pod, QTuple.pod)
    In Types.pod, deleted the data types "TupleD0" (singleton) and
    "RelationD0" (2 values) as they no longer seem useful; then updated the
    descriptions of the "Tuple" and "Relation" data types to give
    additional special names to the corresponding 3 values, "Tuple:d0" and
    "Relation:d0c[0|1]".  Updated any other files having references to the
    "D0" types so they reference the "d0" value names instead.

    * (HDMD_Perl[6|5]_Tiny.pod)  Split up the "GENERAL STRUCTURE" main pod
    section into itself and the new "VALUE LITERALS AND SELECTORS"; then
    the latter was moved to be just above "OPAQUE VALUE LITERALS".  Also
    added the initially empty/todo new main pod section "DEPOT
    DECLARATION", just above "BOOTLOADER STATEMENT".

    * (HDMD_Perl[6|5]_Tiny.pod)  Updated all the main pod sections
    ["GENERAL STRUCTURE", "BOOTLOADER", "LANGUAGE NAME", "VALUE LITERALS
    AND SELECTORS", "OPAQUE VALUE LITERALS", "COLLECTION VALUE SELECTORS"]
    and all their pod sub-sections, to strip out or summarize any Perl-Tiny
    description text that is redundant with the description text of the
    PTMD_Tiny dialect, since the former should now be able to piggyback on
    the latter; otherwise updated or rewrote or cleaned them up.

    * (HDMD_Perl[6|5]_Tiny.pod)  Removed the now-unneeded brief main pod
    section REWRITE PROGRESS MARKER, in both files.

    * (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod)  Other minor updates, fixes.

    * (BBEdit_LM_Muldis_D.plist)  Updated this file to the latest grammar.

2009-04-29  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.66.0 is released on CPAN as
    Muldis-D-0.66.0.tar.gz.

    * This release features major updates and additions to the PTMD_Tiny
    dialect, including fleshing out of descriptive text, such that this
    dialect's definition is now fully self-defined and you no longer have
    to look at the HDMD_Perl[6|5]_Tiny dialects to fill in the gaps.
    That's not to say that the concrete grammars are complete (they're
    not), but now PTMD_Tiny is no longer lagging the other dialects with
    regard to completeness.

    * (Types.pod, Types_Catalog.pod, Basics.pod)  Renamed all of the
    "String" types from the generic "sys.std.Core.Type.\w+" namespace to
    the catalog-focused "sys.std.Core.Type.Cat.\w+" namespace, and moved
    their definitions from Types.pod to Types_Catalog.pod; specifically the
    5 normal types "(|SE|B|O|UCP)String" plus the infinite number of
    "String.*" types were renamed.  The main reason for this change was to
    emphasize that the "String" types are not generally intended for direct
    use with user data, and should only be used mainly by other
    system-defined types and operators in their definitions.

    * (Routines_Catalog.pod, QTuple.pod)  Renamed the 3 functions
    "sys.std.Core.Cat.Order_[[|conditional_]reverse|reduction]" to
    "sys.std.Core.Cat.Order.[[|conditional_]reverse|reduction]".

    * (PTMD_Tiny.pod)  Split the pod section "VALUE LITERAL COMMON
    ELEMENTS" into the 2 sections "VALUE LITERALS AND SELECTORS" and "Value
    Literal Common Elements".  Renamed the illustrative grammar token
    "value" to "x_value", leaving just the one "value" that should actually
    be used in a generic grammar.

    * (PTMD_Tiny.pod)  Updated every kind of quoted character string
    literals so that non-"space" whitespace characters may no longer appear
    literally, but must instead be denoted with escape sequences; to be
    specific, disallowed the 4 characters "\t\n\f\r" from appearing
    literally.  The main reason for this change was to ensure that the
    actual values being selected by char str literals were not variable per
    the kind of linebreaks used to format the Muldis D source code itself.
    These 3 grammar tokens were updated: "[text|comment|_payload]",
    "quoted_name_str".

    * (PTMD_Tiny.pod)  Added another simple escape sequence for quoted char
    str literals, "\s", representing a space (F;20).  Updated "Comment"
    literals so they can have optional leading or trailing space chars
    inside the # delimiters which are not part of the selected Comment
    value; you must escape leading/trailing spaces now if you want them
    included in the value.  These 2 grammar tokens were updated:
    "comment_payload", "escaped_char".

    * (PTMD_Tiny.pod)  Renamed a few generic grammar tokens:
    "int_max_col_val" -> "num_max_col_val", "list_[open|close]" ->
    "nonord_list_[open|close]".

    * (PTMD_Tiny.pod)  Refactored grammar tokens concerning generic
    relations, UTC temporals, etc.  Merged the "qrelation" token into the
    "value" token (and "payload"), then renamed the 2
    "generic_qrelation[|_payload]" to "qrelation[|_payload]", and renamed
    the 3 "generic_relation_\w+_payload" to "r_\w+_payload".  Split the 2
    tokens "utc_instant[|_payload]" into themselves and
    "float_instant[|_payload]", and updated the "value" and "payload"
    tokens accordingly.  Split the token "value" 3 ways into itself and
    "opaque_value_literal" plus "coll_value_selector".

    * (PTMD_Tiny.pod)  Updated the whole PTMD_Tiny grammar to add capturing
    parenthesis, so to help illustrate a map between the concrete grammar
    and anticipated parse tree nodes, which HDMD_Perl[6|5]_Tiny are to a
    large degree.

    * (PTMD_Tiny.pod)  Renamed all the grammar tokens that are either the
    main tokens or main payload tokens for value literals or selectors, so
    to spell the tokens the same way as their "value_kind" components which
    is the resulting type names; for example, the tokens that were named
    "rat_round_meth[|_payload]" are now named "RatRoundMeth[|_payload]".
    This also means that the grammar tokens and capture node names
    ("value_kind") now actually match each other.

    * (PTMD_Tiny.pod)  Split up the following grammar tokens into
    themselves and additional parts, so to make them more self-documenting:
    "Blob_payload", "[[UTC|Float]Instant|UTCDuration]_payload",
    "String_payload", "r_ordered_qattr_payload".

    * (PTMD_Tiny.pod)  Updated the grammar tokens [Int, Rat, Blob,
    UTCInstant, FloatInstant, String, QTuple] and "value_kind" to add one
    or more "value_kind" alternative values which provide a terser
    alternative to common settings of a "value" node's "type_name"; for
    example, added "NNInt", "OctetBlob", "UTCDate", and "Database".

    * (PTMD_Tiny.pod)  Updated the top-level grammar so the language root
    token is "bootloader" and it composes a "language_name" token plus
    exactly one alternative between the 3 tokens "value", "depot", (a
    sequence of) "boot_stmt".  The "depot" one is new, and is declared in
    the new pod section "DEPOT DECLARATION".  Fleshed out the pod sections
    "BOOTLOADER", "VALUE LITERALS AND SELECTORS", "COLLECTION VALUE
    SELECTORS" with their own description paragraphs, and removed now
    redundant text from "GENERAL STRUCTURE".  Also small "DESCRIPTION"
    updates.  Also split the token "boot_stmt" into itself plus
    "generic_boot_stmt", the latter being the first of unspecified
    alternatives in the former, todo in a subsequent release.  The new
    "depot" token references 2 undeclared/todo tokens
    "depot_[catalog|data]".  Also updated the appropriate sub-tokens of
    "Q[Tuple|Relation|Set|Single|Array|Bag" so they now embed "expr" tokens
    rather than "value"; declaring the "expr" token is todo.

    * (PTMD_Tiny.pod)  Updated the "LANGUAGE NAME" main pod section plus
    all the pod sections specific to value node literals/selectors to add
    complete desc paragraphs to each one, all of these derived from their
    counterpart desc text in the HDMD_Perl[6|5]_Tiny.pod files.

    * (PTMD_Tiny.pod)  Removed the now-unneeded brief main pod section
    REWRITE PROGRESS MARKER.

2009-04-28  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.65.1 is released on CPAN as
    Muldis-D-0.65.1.tar.gz.

    * (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod)  Rearranged some POD
    sections:  Moved "BOOTLOADER" to just above "LANGUAGE NAME".  Moved
    "Nothing" to just above "Bool".  Moved "Order" and "RatRoundMeth" to
    just below "Bool".  Moved "Rat" to just below "Int".  Moved
    "[Instant|Duration]" to just below "Comment".  Moved
    "[UTCInstant|FloatInstant|UTCDuration]" to just below "Duration".
    Moved "String" to just below "UTCDuration".  Renamed "SIMPLE CORE
    SCALAR VALUE LITERALS" to "OPAQUE VALUE LITERALS", and "GENERIC
    Q/SCALAR AND Q/NONSCALAR VALUE LITERALS" to "COLLECTION VALUE
    SELECTORS", and removed the now-empty "TEMPORAL EXTENSION SCALAR VALUE
    LITERALS" heading.  Following these changes, "OPAQUE ..." has "Nothing"
    plus all the q/scalar selectors, including all the temporal selectors,
    but not "[|Q]Scalar", and "COLLECTION ..." has "[|Q]Scalar" plus all
    the q/nonscalar selectors, but not "Nothing".  The distinction between
    these 2 new groups is that "COLLECTION ..." has all the selectors which
    are visibly collections of other nodes, while "OPAQUE ..." has all the
    selectors which visibly have no component nodes; the latter are always
    constant expressions while the former might vary at runtime if child
    nodes are say function invocations or routine parameters.

    * (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod)  Renamed all the level-2 /
    type-specific pod section headings from "sys.std.Core[.Cat]?.\w+" to
    headings that are more generic, in the process also merging a few
    similar such pod sections; 24 sections per file became 20.  The 3
    sections "[Name|NameChain|DeclNameChain]" merged into the 1 "DBMS
    Entity Name Literals", the 2 sections "[Instant|Duration]" merged into
    the 1 "TAI Temporal Literals", the 2 sections
    "[[UTC|Float]Instant|Duration]" merged into the 1 "UTC and Float
    Temporal Literals".  The simple renames were these 17 sections:
    "Nothing" -> "The Nothing Literal", "Bool" -> "Boolean Literals",
    "Order" -> "Order-Determination Literals", "RatRoundMeth" -> "Rational
    Rounding Method Literals", "[Int|Rat]" -> "General Purpose
    [Integer|Rational] Numeric Literals", "[Blob|Text]" -> "General Purpose
    [Binary|Character] String Literals", "Comment" -> "Code Comment
    Literals", "String" -> "Low Level Integer String Literals", "Tuple" ->
    "Tuple and Database Selectors",
    "[Q|][Scalar|Relation|Set|Single|Array|Bag]" ->
    "[Scalar|Relation|Set|Single|Array|Bag] Selectors",

    * (HDMD_Perl[6|5]_Tiny.pod)  Various other minor updates and fixes.

2009-04-22  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.65.0 is released on CPAN as
    Muldis-D-0.65.0.tar.gz.

    * (PTMD_Tiny.pod)  Updated the possible simple escape sequences
    allowable in quoted character string literals.  The escape for
    backslash (F;5C), "\b", is unchanged.  The escape for
    apostrophe/single-quote (F;27) is now "\a" rather than "\q".  Added 2
    more escapes for visible characters, "\q" for double-quote (F;22) and
    "\h" for number-sign/hash (F;23).  Also added 4 more escapes for the
    most commonly written out invisible/control characters, that match
    their common meanings: "\t" for tab (F;9), "\n" for line-feed/newline
    (F;A), "\f" for form feed (F;C), "\r" for carriage return (F;D).  Note
    that, unlike with Perl/etc where the meaning of "\n"/etc may change
    depending on context, in Muldis D each escape always represents the
    same single Unicode codepoint.  The multi-part escape sequences
    "\c<...>" were unchanged.  As part of this update, the grammar token
    "quoted_char_str" was split into itself and "escaped_char".

    * (PTMD_Tiny.pod)  Differentiated further the 3 main kinds of character
    string literals (Text/Blob, Name/chains, Comment) by giving each
    different delimiter characters.  Text and Blob retain their existing
    apostrophe/single-quote delimiters.  Name and chains based on it now
    have double-quote delimiters when they are quoted at all, and they can
    still be barewords where they could before; in practice there is little
    change here since most Name/chains tend to be barewords.  Comment now
    has numer-sign/hash delimiters, so it looks much like a Perl/etc
    comment except that a trailing # is also necessary; furthermore,
    segmented Comment literals now no longer use a tilde/~ between segments
    (Text/Name/etc still do), rather they just have optional whitespace
    between segments.  Regarding char escape sequences, within each kind of
    quoted character string literals, it is only mandatory to escape the
    same character as delimits that particular literal plus the backspace;
    using the other escapes is optional.  As part of this update, the
    grammar token "quoted_char_str" was removed and a customized version
    inlined into each payload/etc token that used to include it, and the
    tokens related to Name literal payloads were reorganized.  Also updated
    all relevant code examples to reflect the delimiter changes for
    Name/etc and Comment.

    * (D.pm, PTMD_Tiny.pod)  The previous change item also affected the
    format of PTMD_Tiny fully-qualified Muldis D language names; the
    authority and version number parts are now delimited with double-quotes
    as per Name, rather than single-quotes.

    * (PTMD_Tiny.pod)  Updated the support for unqualified value literals
    so "Comment" literals may now be written that way.  The only updated
    grammar token is "comment".

    * (BBEdit_LM_Muldis_D.plist)  Partially rewrote this file, mainly the
    syntax coloring regexes, to be cleaner and to reflect the previous
    PTMD_Tiny change items.  Also, Name/NameChain/DeclNameChain literals
    are no longer colored at all, since in general they should be treated
    consistently as identifiers.  Also, the "value kind" barewords,
    essentially all the unqualified main type names, are no longer colored
    as language keywords, as they should be treated consistently with
    either type or routine invocation names.

    * (BBEdit_LM_Muldis_D.plist)  Made several additions corresponding to
    anticipated PTMD_Tiny grammar that is yet to be codified in the spec.
    Rewrote the routine scanning pattern to look for
    "[inner_]?[function|updater|procedure]" rather than "[name|'name'] \s*
    => \s* Name:".  Added a couple dozen new keywords to the syntax
    colorer, including both the routine makers and a bunch of possible
    infix operators that are actually sugar over normal prefix operators.

    * (Basics.pod, Types_Catalog.pod, Routines.pod, Ordered.pod,
    QTuple.pod, QSet.pod)  In Basics.pod, in the "Ordered Types"
    sub-section of "TYPE SYSTEM", updated the definition of an
    "order_determination" routine to give it a 4th, boolean parameter,
    "is_reverse_order", which is mandatory to define but optional to
    invoke.  It is now normal/expected that every order-determination
    function will fundamentally know how to operate both normally and in
    reverse, and support an ascending or descending value sort, with that
    ability being orthogonal to any other customizability it might have.
    In Types_Catalog.pod, updated the description of the "order" attribute
    of the "InnerScalarType" type to conform to the updated ord-det routine
    definition.  In Routines.pod, updated the "sys.std.Core.QScalar.order"
    function to add a "is_reverse_order" parameter.  In Ordered.pod,
    deleted function "sys.std.Ordered.reverse_order", which is no longer
    useful, and updated the description of the 2 functions
    "sys.std.Ordered.is_[|not_]before".  In QTuple.pod, updated the
    "sys.std.QTuple.order_by_attr_names" function to add a
    "is_reverse_order" parameter and otherwise update its description.  In
    QSet.pod, updated the description of the "sys.std.QSet.QMaybe.order"
    function.

    * (Routines_Catalog.pod)  In Routines_Catalog.pod, added new function
    "sys.std.Core.Cat.Order_conditional_reverse", which should make the
    task of writing (bi-directional) generic "order_determination" routines
    easier, for those who want to write the least code to do the job.

    * (QRelation.pod, QArray.pod)  Updated each of the following 9
    functions to add a "is_reverse_order" parameter:
    "sys.std.QRelation.[rank|limit][|_by_attr_names]",
    "sys.std.QArray.[|limit_of_]QArray_from_wrap[|_by_attr_names]",
    "sys.std.QArray.QArray_from_attr".

    * (Integer.pod, Rational.pod, Temporal.pod)  Updated all 6 "sum" or
    "product" N-ary functions to rename each of their sole parameters to
    "topic" from "addends" or "factors" that they were before.  While
    strictly speaking the old names were more descriptive, the new names
    allow for better standardization in that all the other N-ary functions
    of Muldis D already named their sole/primary parameter "topic".

    * (Routines.pod)  Other minor fixes.

2009-04-16  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.64.0 is released on CPAN as
    Muldis-D-0.64.0.tar.gz.

    * (Basics.pod)  Minor updates to "NOTES ON TERMINOLOGY", clarifying
    that a value literal is a common special case of a selector, and also
    that a constant may alternately be a niladic function.

    * (Types_Catalog.pod, Routines_Catalog.pod)  Renamed the 8 relation
    types "ScaLitExprNodeSet" and
    "[ScaPR|Tup|Rel|[Func|Proc|Type|OrdDetFunc]Ref]LitExprNodeSet" to
    "ScaValExprNodeSet" and
    "[ScaPR|Tup|Rel|[Func|Proc|Type|OrdDetFunc]Ref]SelExprNodeSet"; the old
    names were actually inappropriate because partly the concept of a
    literal doesn't exist in a type definition (just in concrete code), and
    also child nodes of these nodes are often non-literal expressions such
    as function invocations.  Also renamed the corresponding 8 attributes
    of the database type "ExprNodeType", and updated the few other
    references to the renamed types to use the new names.

    * (Types_Catalog.pod)  Added 3 new relation types
    "sys.std.Core.Type.Cat.[Set|Ary|Bag]SelExprNodeSet" which are like
    specialized versions of "RelSelExprNodeSet", with a simpler structure
    for the commonly used Set|Array|Bag value selectors.  Also added 3 new
    corresponding attributes to the "ExprNodeType" type.

    * (Types_Catalog.pod)  Corrected an omission in the tuple type
    "sys.std.Core.Type.Cat.InnerScalarType" by adding a new attribute
    "subtype_constraint", used when we are defining a proper subtype of
    another type, which constrains the base type's value set at least
    enough such that the new type's possrep maps can work without error,
    and it is possible for the new type's possreps' constraints to operate
    without error.  Also updated a few other cat type/attr descriptions.

    * (Types_Catalog.pod, QTuple.pod, QRelation.pod, QArray.pod)  Added new
    order-determination function "sys.std.QTuple.order_by_attr_names" which
    provides a convenient short-hand for ordering tuples of a relation
    simply in terms of a list of attribute names; this saves users having
    to declare their own order-determination function for this common
    format of queries; also added new type
    "sys.std.Core.Type.Cat.OrderByName" used by said new function.  Also
    added the 4 new wrapper functions
    "sys.std.QRelation.[rank|limit]_by_attr_names" and
    "sys.std.QArray.[|limit_of_]QArray_from_wrap_by_attr_names" which
    combine the previous function with their partial namesakes.  And so
    Muldis D now provides a direct analogy to the SQL syntax "ORDER BY foo,
    bar" etc that doesn't need a user-defined closure, though you still
    need the latter for the general case of "ORDER BY <expr>".

    * (Routines.pod)  Changed the "sys.std.Core.QRelation.summary" function
    by renaming its "result_attr_names" parameter to "summ_attr_names" and
    redefining its functionality more in terms of "extension" rather than
    "map"; the function given to "summ_func" must now just result in a
    tuple with attributes to add to a result which now already has all the
    attributes named by "group_per", rather than resulting in all
    attributes for the result.  The new version of "summary" should be much
    easier to use as presumably users always want to keep the attributes
    they are grouping per, and they now don't have to spell them out every
    time.  For the rare case where you want the old behaviour, now you have
    to do it manually with an explicit "cmpl_group" plus "map".

    * (Routines.pod, QBag.pod)  Added new function
    "sys.std.Core.QRelation.cardinality_per_group" which is like "summary"
    but shorthands the common case where people just want a count of tuples
    per group and not any other information.  Also added new function
    "sys.std.QBag.QBag_from_cmpl_group" which is like the other new
    function but the result is a QBag.

    * (QBag.pod)  Added new function "sys.std.QBag.union_sum" which is like
    "sys.std.QBag.union" but that counts in the result come from summing
    the counts of the inputs rather than taking maximums of said.  Also
    updated the description of "sys.std.QBag.insertion" to clarify it is
    semantically like "union_sum" and not "sys.std.QBag.union" which is the
    direct analogy to set union.

    * Added new file "lib/Muldis/D/Ext/Counted.pod" which houses the new
    "Muldis D Counted Extension".  This extension defines special
    count-sensitive versions of all the common and applicable relational
    operators in Routines.pod and QRelation.pod, each new one taking an
    extra $count_attr_name argument that specifies which attribute of each
    normal argument contains the count and is to be treated specially, such
    that generally just the other attributes are considered in regards to
    the normal semantics of the operators, and the count attributes are
    summed or diffed as is appropriate.  Having these operators
    system-defined is probably the best way to support people who actually
    want bag-of-tuple semantics, or most precisely simulate the general
    case of bag-of-tuple behaviour of SQL for those using Muldis D as an
    intermediate representation, and then various users won't be
    reimplementing that wheel as multiple incompatible extensions.  This
    file has an initial complement of 22 new functions, all in the
    "sys.std.Counted.\w+" namespace: "[add|remove]_count_attr",
    "counted_[cardinality|is_[|not_]member|insertion|deletion]",
    "counted_[[|cmpl_]projection|[|maybe_]reduction|map]",
    "counted_is_[|not_][|proper_]subset",
    "counted_[union[|_sum]|intersection|difference]"
    "counted_[|static_]substitution".

    * (D.pm, Core.pod, README)  Added basic references to the new
    Counted.pod file.

    * (HDMD_Perl5_Tiny.pod)  Fixed a few detail fossils that became
    obsolete with last release's PTMD_Tiny changes.  Updated details for
    PHMD payloads of these 4 types: Bool, Int, Rat, Order.

    * (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod)  Removed a fossil each that
    referenced the concept of a scalar without a possrep.

    * (Basics.pod, Routines.pod, Types_Catalog.pod, Ordered.pod,
    QRelation.pod)  Minor updates.

2009-04-02  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.63.0 is released on CPAN as
    Muldis-D-0.63.0.tar.gz.

    * Added new file "util/BBEdit_LM_Muldis_D.plist" which is the first cut
    of a Codeless Language Module for the BBEdit text editor for Mac OS X
    that empowers BBEdit to syntax color and function scan code written in
    the PTMD_Tiny dialect of Muldis D.  Also added the support file
    "util/README" which explains the CLM further.  The new CLM is only as
    complete as the language spec itself, and mainly what it is the most
    complete about is syntax coloring Muldis D value literals.  Also
    updated the README file to refer to the "util/" and "archives/" dirs.
    While not exactly its intended use, you can get a taste of the CLM
    working by opening the PTMD_Tiny.pod file in BBEdit with the CLM
    installed and look at the various code examples in the POD file.

    * (Types_Catalog.pod)  Updated the "RatRoundRule" type to replace its
    "max_denom" attr (a "PInt") with a "min_exp" attr (an "Int").  This
    change was made so that rounding could be specified more easily and
    tersely; as well this change adds a feature in that rounding can now be
    specified to a multiple of a whole number greater than one, and not
    just to a multiple of a number of lesser or equal magnitude to one.

    * (PTMD_Tiny.pod)  Made "Name" (and chains etc) value literals stricter
    in a couple ways.  First, segmented Name payloads must now have all of
    their segments quoted, not just those segments with characters outside
    of the nonquoted repertoire; a corollary to this is that if you have an
    otherwise nonquoted Name payload that is long enough to segment, you
    have to make it quoted to do that.  Second, nonquoted Name payloads
    must begin with a letter or underscore and may no longer start with a
    digit or hyphen; you must use the quoted form if you want to do that.
    These changes were made to aid code readability and reduce confusion of
    some Name literals with some Int literals.  In the process, a bit of
    grammar refactoring was done: "quoted_char_str_seg" was enlarged to
    include "segment_sep" and was renamed to "quoted_char_str", and now
    "[text|name|comment]_payload" refer to that; "nonquoted_char_str_seg"
    was renamed to "nonquoted_char_str".

    * (PTMD_Tiny.pod)  Made "Bool" and "Order" value literals stricter such
    that they may only be specified with values allowed for their "name"
    possreps and no longer their "int" possreps.  So for example, you can
    say "Bool:false" or "false" but no longer "Bool:0".  Updated grammar
    tokens are "bool[|_payload]" and "order_payload".

    * (PTMD_Tiny.pod)  Updated the support for unqualified value literals
    so "Order" and "RatRoundMeth" literals may now be written that way.
    Updated grammar tokens are "order" and "rat_round_meth".

    * (PTMD_Tiny.pod)  Made the grammar token "pint_tail" stricter so that
    two underscore separator characters may not appear in a row within any
    of the value literals defined in terms of numeric values.

    * (PTMD_Tiny.pod)  Fixed a bug concerning all value literals defined in
    terms of numeric values where the int-max-col-val prefix is omitted;
    then the grammar should have allowed only the digits [0..9] are allowed
    in the numeric, rather than the [0..9A..F] allowed when the
    int-max-col-val is given.  This affects the 8 types: Int, String, Rat,
    Instant, Duration, [UTC|Float]Instant, UTCDuration, Bag.  In the
    process, added 7 grammar tokens each like the following 7 but for "d_"
    (decimal) prefixed to their name: "[|nn|p]int_body",
    "pint_[head|tail]", "[|nn]rat_body"; and updated the 8 grammar tokens:
    "[int|string|rat][[|utc_][instant|duration]]_payload", "count".

    * (PTMD_Tiny.pod)  Fixed a bug concerning the "DeclNameChain" value
    literal format where the SCVL of that type with zero elements is simply
    the empty string, or the GCVL of the same has a trailing colon.  To fix
    this, updated the "decl_name_chain_payload" grammar token so that a
    zero-element DeclNameChain is represented by the special payload "[]";
    however, any DNC (or NC) with at least one element still have no "[]"
    delimiters surrounding the chain literal (unlike for "String" etc).

    * (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod)  For each dialect, added an
    example for each of the types "DeclNameChain" and "RatRoundMeth".

    * (D.pm, SeeAlso.pod)  Minor updates; changed notes about projects'
    owners from Darren Duncan to Muldis Data Systems.

2009-03-20  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.62.3 is released on CPAN as
    Muldis-D-0.62.3.tar.gz.

    * (Routines_Catalog.pod)  Fixed a few search+replace errors that
    release 0.62.2 introduced.

    * (Basics.pod, Types.pod, Routines.pod, Types_Catalog.pod,
    Routines_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod,
    Ordered.pod, Integer.pod, Blob.pod, Text.pod, Rational.pod,
    Temporal.pod)  General documentation reformat considering a frequently
    employed writing short-hand.  Often when text alternatives were
    displayed, and they had portions in common, the short-hand used fake
    Perl regex syntax; the main change was to update the short-hand to
    resemble Perl 6 syntax more and Perl 5 syntax less, mostly by
    substituting "[]" (non-capturing group) for "()".  This change was made
    partly so the new version is more readable considering "()" are used
    for other purposes in the same contexts while "[]" weren't.  It also
    brings greater consistency since Perl 6 rules are the standard format
    in other parts of the documentation for illustrating patterns.

2009-03-19  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.62.2 is released on CPAN as
    Muldis-D-0.62.2.tar.gz.

    * (Routines.pod, Routines_Catalog.pod, Ordered.pod, Integer.pod,
    Blob.pod, Text.pod, Rational.pod, QTuple.pod, QRelation.pod, QSet.pod,
    QArray.pod, QBag.pod, Temporal.pod)  Second draft at reformatting all
    system-defined routine signatures to match the planned new PTMD_Tiny
    format for declaring routines.  Where parameter declarations used to be
    formatted "p1(T1)" or "&p1(T1)" or "&p1(T1)?", they are now formatted
    "T1 $p1" or "T1 &$p1" or "T1 $p1?".  This change does not alter the
    verbosity one bit, but the code is arguably a lot prettier and easier
    to read or write.  So now PTMD_Tiny routine declarations now look
    almost identical in format to Perl 6 declarations, in fact at a glance
    one might confuse it for Perl 6.  Note for those of you accustomed to
    Perl 6 of these small differences: 1. all Muldis D params are named but
    don't have the ':' prefix like Perl 6; 2. the $ is not actually part of
    the parameter name, just syntactic sugar to help the grammar (there are
    no @%... sigils); 3. pass-by-ref params are marked with & not "is ref".

2009-03-19  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.62.1 is released on CPAN as
    Muldis-D-0.62.1.tar.gz.

    * (Routines.pod, Routines_Catalog.pod, Ordered.pod, Integer.pod,
    Blob.pod, Text.pod, Rational.pod, QTuple.pod, QRelation.pod, QSet.pod,
    QArray.pod, QBag.pod, Temporal.pod)  First draft at reformatting all
    system-defined routine signatures to match the planned new PTMD_Tiny
    format for declaring routines.  Where function declarations used to be
    formatted "function f result T0 params { p1(T1), p2(T2) }", they are
    now formatted "function f (T0 <-- p1(T1), p2(T2))", and where
    procedures/etc used to be formatted "procedure p update { p1(T1) } read
    { p2(T2) }", they are now formatted "procedure p (&p1(T1), p2(T2))".  A
    main benefit of this change is routine signatures should be
    considerably less verbose and easier to read and more like those of
    other languages, and also now subject-to-update parameters may now be
    mixed with read-only parameters, since the & prefix now is what
    indicates their being subject-to-update; similarly, routine invocations
    would use the & for subject-to-update arguments as well.

2009-03-17  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.62.0 is released on CPAN as
    Muldis-D-0.62.0.tar.gz.

    * Congratulations to the developers of Parrot (Speaks Your Language),
    which saw its long-awaited 1.0.0 release earlier today.

    * (PTMD_Tiny.pod)  Updated the "quoted_char_str_seg" grammar token to
    add support for specifying characters in terms of their Unicode
    codepoint name or number, in addition to the previous means of
    specifying characters as their literal selves in the presumably Unicode
    PTMD_Tiny source code.  The new feature is in the form of the escape
    pattern "\c<...>", where that any occurrences of such a substring in a
    quoted character string literal are replaced with the actual Unicode
    codepoint whose name or number is given by the "..."; the "..." takes a
    form like either "A..Z " for character names (example "\c<LATIN SMALL
    LETTER OU>") or "\d;\d+"|"\d+" for character numbers (examples
    "\c<F;263A>" or "\c<65>".  One reason for this feature is to empower
    specifying exactly which sequence of codepoints you want for a
    particular grapheme (which text editors tend to abstract away when you
    write characters literally), and also it is to empower more elegant
    passing of Unicode-savvy PTMD_Tiny source code through a communications
    channel that is more limited, such as to 7-bit ASCII.

    * (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod)  Added "Text" value literal
    example to all 3 Tiny grammars illustrating how to specify characters
    in terms of Unicode codepoint names or numbers.

    * (PTMD_Tiny.pod)  Updated the "[|nn]rat_body" grammar tokens to be
    stricter such that rational-type numbers now may never look like
    integer-type numbers; specifically, where you used to be able to say
    "Rat:42" you must instead say "Rat:42.0".  This change affects not just
    "Rat" value literals but also "Instant", "Duration", and "UTC"/"Float"
    versions of the latter.  This change was made partly to aid code
    self-documentation and syntax highlighting, as well as support a
    subsequent change item (unqualified value literals).

    * (HDMD_Perl[5|6]_Tiny.pod)  Updates corresponding to previous change
    item, as was appropriate for each Perl version.

    * (PTMD_Tiny.pod)  Updated the "blob_payload" grammar token so that the
    string must be quoted rather than unquoted.  This change was made
    partly to aid syntax highlighting, especially with the empty string, as
    well as to support a subsequent change item (unqual value literals).

    * (PTMD_Tiny.pod)  Made "Text" and "Comment" value literals stricter
    such that all of their character string segments must be quoted; now
    only "Name"/etc character strings allow unquoted string segments.  In
    the process, did a bit of grammar refactoring that eliminated the
    "char_str[|_seg]" tokens and updated the "[text|name|comment]_payload"
    and "ln_base_[authority|version_number]" tokens.  This change was made
    to aid code readability as well as support a subsequent change item
    (unqualified value literals).

    * (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod)  Updated the Tiny dialects
    to add support for specifying generic context value literals of certain
    data types as just their payloads, without explicit "value kind"
    metadata; that is, added support for unqualified value literals.  Which
    data types this new feature is allowed to be used with varies by
    dialect.  With PTMD_Tiny, the 5 types [Bool, Int, Blob, Text, Rat] are
    supported.  With HDMD_Perl6_Tiny, the 8 types [Bool, Int, Blob, Text,
    Rat, Instant, Duration, Order] are supported.  With HDMD_Perl5_Tiny,
    the 3 types [Int, Text, Rat] are supported, albeit less rigorously.
    This change was made to aid code brevity and to make Muldis D
    significantly more like typical programming languages in regards to how
    one writes character string or numeric literals; in fact those formats
    are now exactly the same in general.  Most example code was updated to
    the new terse format, with typically just one example per type
    remaining in the old fully qualified format.  No grammar tokens were
    added, just some were changed.

    * (Routines.pod, Ordered.pod, Integer.pod)  Added the 6 new functions
    ["sys.std.Core.QRelation.[restriction_and_cmpl|semijoin_and_diff]",
    "sys.std.Ordered.[|maybe_]minmax",
    "sys.std.Integer.[|maybe_]quotient_and_remainder"]; each of these is
    just a wrapper over a pair of other mutually complementary functions.

    * (QRelation.pod)  Added new function
    "sys.std.QRelation.classification" which is sort of a cross between
    "restriction" and "group"; it uses a user-defined function argument to
    partition a q/relation's tuples into an arbitrary number of groups.

2009-03-13  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.61.0 is released on CPAN as
    Muldis-D-0.61.0.tar.gz.

    * A Friday the 13th release.

    * (HDMD_Perl6_Tiny.pod)  Corrected the new Instant|Duration value
    literals to say that their payloads are simply Perl 6 Instant and
    Duration values, which are directly mapped, same as with value literals
    for [Bool, Int, Blob, Text, Rat, Name, Comment, Order] etc.  The
    previous descs saying to use Rat payloads only applied for Perl 5 Tiny.

    * (Basics.pod, Types.pod, Types_Catalog.pod, Routines.pod)  Updated the
    core type "Int" so it is no longer a primitive type but rather now is a
    structure type, which is defined in terms of a single-element "String"
    attribute; also added new core type "sys.std.Core.Type.SEString", a
    subtype of "String", for use in defining the updated "Int".  Also found
    any other references to the "Int" type that said it was primitive or
    had no possreps etc and updated them.

    * (Basics.pod, Types.pod, Types_Catalog.pod, Routines.pod)  Updated the
    core type "String" so it is no longer a primitive type but rather now
    is an enumeration type, which is implicitly defined in terms of a union
    over an infinite number of implicitly defined
    "sys.std.Core.Type.String.*"-named singleton structure types, each one
    being named with its value.  To support the infinite new implicit
    types, updated the "Name" type so its sole possrep's sole attribute is
    now "String" typed, rather than being "UCPString" typed like "Text".
    However, actual user exploitation of the new flexibility of "Name" is
    strongly discouraged, to the point that all of the standard Muldis D
    dialects remain unchanged and so "Name" value literals still only
    support what is supported for "Text", and one can only select one of
    the newer "Name" values by way of a "Scalar" value literal plus a
    "String" value literal.  Also found any other references to the
    "String" type that said it was primitive or had no possreps etc and
    updated them.

    * Following the last 2 change items, Muldis D has only 2 "primitive"
    types left, which are "QTuple" and "QRelation".  Moreover, Muldis D no
    longer has the concept of q/scalar root type with no possreps; all
    system-defined or otherwise q/scalar values now have 1/+ possreps.

    * (Routines.pod, QTuple.pod, QRelation.pod)  Updated all 15 functions
    and 5 updaters that had a "set_of.Name"-typed parameter named
    "[|\w+_]attrs" and renamed said parameter to "[|\w+_]attr_names"; any
    similarly named parameters that were of some other type, such as
    "QTuple", kept their old names.  This change should make the parameters
    more self-documenting, since "attrs" names now tend to have both
    attribute names and values, where as "attr_names" have just names.  The
    changed 20 routines were:
    "sys.std.Core.Q[Scalar|Tuple|Relation].[|cmpl_]projection",
    "sys.std.Core.Q[Tuple|Relation].assign_[|cmpl_]projection",
    "sys.std.Core.QRelation.[summary|[|assign_]extension]",
    "sys.std.[Core.QScalar|Q[Tuple|Relation]].has_attrs",
    "sys.std.QRelation.[map|substitution|subst_in_[restr|semijoin]]".

    * (QRelation.pod)  Added new function "sys.std.QRelation.has_key".

    * (PTMD_Tiny.pod, Temporal.pod)  Minor fixes.

2009-02-25  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.60.0 is released on CPAN as
    Muldis-D-0.60.0.tar.gz.

    * (Types.pod)  Minor update to ambiguity-reduce the descriptions of 8
    types; replaced the text "its cardinality is" with the text "the
    cardinality of this type is"; the remaining types already used the
    newer wording.  Further related minor update with the 3 types [QMaybe,
    Nothing, QSingle] regarding text like "is a proper subtype of" that
    talks about the number of elements it has; this was updated to clarify
    it is talking about how many elements each member value of the type
    has, and it is not talking about how many member values the type has.

    * (Types.pod, Types_Catalog.pod, Rational.pod, PTMD_Tiny.pod,
    HDMD_Perl(5|6)_Tiny.pod, Basics.pod, Core.pod, Temporal.pod, D.pm, the
    README file)  Promoted the 6 rational numeric concerning types [Rat,
    NNRat, PRat, PInt2_N, RatRound(Meth|Rule)] to the language core, where
    they how have a status like Blob and Text, which is being not necessary
    for bootstrapping a minimal Muldis D, but still being highly important
    for user data nonetheless; this said, in the near future, Rat may
    become needed by the system catalog if the latter starts storing
    time-stamps.  The 4 type declarations [Rat, NNRat, PRat, PInt2_N] were
    moved from Rational.pod to Types.pod, and their namespace changed from
    "sys.std.Rational.Type.\w+" to "sys.std.Core.Type.\w+"; the 2 type
    declarations [RatRound(Meth|Rule)] were moved from Rational.pod to
    Types_Catalog.pod, and their namespace changed similarly but for an
    extra ".Cat"; all 6 types were exactly the same after the move, except
    that the types' fully qualified names changed.  After these moves,
    Rational.pod has declarations for just the 3 types [BRat, DRat,
    PInt2_36]; all of its routines were kept, unchanged.  In each of the 3
    Tiny dialect files, the literal syntax for "Rat" and "RatRoundMeth" was
    moved upwards to go next to the appropriate other core scalar types,
    and the main documentation section "RATIONAL EXTENSION SCALAR VALUE
    LITERALS" no longer exists.  Any other files that referred to rational
    types or the rational extension were appropriately updated.

    * (Temporal.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod)  Renamed the
    type "sys.std.Temporal.Type.Duration" to
    "sys.std.Temporal.Type.UTCDuration", in order to avoid a short-name
    conflict with an upcoming new type.  Also correspondingly renamed the
    "sys.std.Temporal.Duration.\w+" namespace.  For each of the Tiny
    dialects, also renamed the corresponding value literal node name from
    'Duration' to 'UTCDuration'.  In PTMD_Tiny.pod, renamed the 4 tokens
    "(instant|duration)(|_payload)" to prepend "utc_".

    * (Types.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod)  Added the 2 new
    scalar types "sys.std.Core.Type.(Instant|Duration)" to the language
    core (Types.pod) and added corresponding special value literal syntax
    for them to all the Tiny dialects.  Unlike the existing types in
    Temporal.pod, which are focused more on calendar-based artifacts with
    distinct YMDHIS components and will DWIM with future dates, the new,
    disjoint types in Types.pod are simply counts of seconds in the TAI
    time scale, and are now the recommended types for tasks like timestamps
    or benchmarks or scientific applications.  The representation of each
    of these 2 new types is a rational numeric, and their Tiny literal
    syntax is exactly the same as for 'Rat' save for the different
    [Instant, Duration] value kind.  Within the language core, the 2 new
    types have the same status as 'Rat', which is being not necessary for
    bootstrapping a minimal Muldis D, but still being highly important for
    user data nonetheless; this said, in the near future, at least
    'Instant' may become needed by the system catalog if the latter starts
    storing time-stamps.

    * (Temporal.pod)  Added an initial complement of 7 new functions
    "sys.std.Temporal.Instant.((|abs_)difference|later|earlier)",
    "sys.std.Temporal.Duration.(abs|sum|difference)" and 1 new system
    service "sys.std.Temporal.Instant.fetch_current_instant" to go with the
    new core language "Instant" and "Duration" types as used in isolation
    from the additional types that Temporal.pod declares.

    * (Temporal.pod)  Added an initial complement of 2 new functions
    "sys.std.Temporal.UTCInstant.(UTC_from_TAI|TAI_from_UTC)", in the new
    main documentation section "FUNCTIONS FOR CONVERSION BETWEEN UTC AND
    TAI", which are for mapping "Instant" and "UTCDateTime" values.

    * (Basics.pod, Routines.pod, Rational.pod, Temporal.pod)  Minor updates
    and fixes.

2009-02-07  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.59.1 is released on CPAN as
    Muldis-D-0.59.1.tar.gz.

    * (Routines.pod, Routines_Catalog.pod, Ordered.pod, Integer.pod,
    Blob.pod, Text.pod, QTuple.pod, QRelation.pod, QSet.pod, QArray.pod,
    QBag.pod, Rational.pod, Temporal.pod)  Some POD reformatting:  Took
    what used to be some level-2 headings that grouped lists of routines
    and changed said into level-1 headings, but did not uppercase their
    text.  Then converted the routine lists from being "=over/=item
    <routine>/=back" to each routine having its own level-2 heading.  For
    each routine, the new heading is just the (fully-qualified) name of the
    routine, and the full signature of the routine displays just as its own
    paragraph.  All these changes combined should look visually like we are
    faking 3 levels of headings, with top and middle being upcased and
    mixed case "=head1" respectively.

    * (Spatial.pod)  Did similar to the previous change item but with the
    type list in Spatial.pod, so that is now formatted like all the other
    type lists in the spec, with a level-2 heading per type.

2009-02-07  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.59.0 is released on CPAN as
    Muldis-D-0.59.0.tar.gz.

    * This release features a set of smaller language enhancements that
    were inspired during development of the module Set::Relation version
    0.5.0 for Perl 5.  Set::Relation 0.5.0 also inspired plans for other
    language enhancements but those have been deferred to a future release.

    * (QRelation.pod)  Renamed the 10 "sys.std.QRelation."-namespace
    routines ["(|assign_)(|static_)substitution_in_(restriction|semijoin)",
    "outer_join_with_(|static_)extension"] to the much shorter
    abbreviations ["(|assign_)(|static_)subst_in_(restr|semijoin)",
    "outer_join_with_(|static_)exten"], so they are easier to type.

    * (QRelation.pod)  Updated each of the 3 functions
    "sys.std.QRelation.subst(|_in_(restr|semijoin))" to add the 1
    non-optional parameter "(|subst_)attrs", which lets the user spell out
    exactly which topic attrs are the ones that may be getting their values
    updated by the closure argument; while not strictly necessary, this
    extra constraint should force any use of each function to be more
    predictable and easier to implement.

    * (QTuple.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod)  Renamed the 1
    function "sys.std.QTuple.substitution_in_default" to
    "sys.std.QTuple.subst_in_default".

    * (Basics.pod, Types.pod, Routines.pod, QRelation.pod, QSet.pod)  A few
    minor description updates or fixes.

    * (README, D.pm)  Added mentions of Set::Relation in SUPPORT/FORUMS.

    * Updated all files with a "LICENSE AND COPYRIGHT" documentation
    section to change the Copyright declaration from "Darren Duncan" to
    "Muldis Data Systems, Inc." (which is wholly owned by Darren Duncan).

2009-01-19  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.58.0 is released on CPAN as
    Muldis-D-0.58.0.tar.gz.

    * This release features a set of smaller language enhancements that
    were inspired during development of the module Set::Relation version
    0.0.0 for Perl 5.  These 2 releases were made in tandem.

    * (PTMD_Tiny.pod)  Renamed the grammar token "nc_elem_sep" to
    "name_chain_elem_sep" and refactored it to embed optional whitespace.

    * (Basics.pod, Routines_Catalog.pod)  A few minor fixes.

    * (Routines.pod, QRelation.pod)  Updated the 4 routines
    ["sys.std.Core.QRelation.((|assign_)extension|summary)",
    "sys.std.QRelation.map"] to add a "attrs" parameter; this is necessary
    in the general case where the "topic" parameter may have zero q/tuples,
    meaning the function that would otherwise define the added/result attrs
    wouldn't be invoked and said new attributes are not otherwise known.

    * (Routines.pod, QRelation.pod)  Added 1 routine
    "sys.std.Core.QTuple.static_extension" (dyadic version of "product"),
    renamed "sys.std.Core.QTuple.assign_product" to
    "assign_static_extension" (and its param "other" to "attrs"), and
    renamed "sys.std.QRelation.outer_join_with_product" to
    "outer_join_with_static_extension"; the new names are easier to
    understand, and the name "product" is saved for just N-adic operators.
    Also renamed the "sys.std.QRelation.composition" parameters from
    "r1|r2" to "topic|other".

    * (QRelation.pod)  Added the 2 new relational operators
    "is(|_not)_disjoint", which test if the intersection of their 2
    arguments is/is-not empty.

    * (QTuple.pod, QRelation.pod)  Added the 4 new relational operators
    "sys.std.Q(Tuple|Relation).is(|_not)_nullary", which complement the 2
    "is(|_not)_empty" operators; they test if the sole argument has zero
    attributes or not.

    * (Routines.pod, QRelation.pod)  A few minor description updates.

    * (SeeAlso.pod)  Updated the "CURRENT IMPLEMENTATIONS OF MULDIS D" main
    section to add 2 new items, which are the Set::Relation module for Perl
    5 and Perl 6 respectively.

2009-01-08  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.57.0 is released on CPAN as
    Muldis-D-0.57.0.tar.gz.

    * (Types_Catalog.pod)  Eliminated the "SysScaNPRTypeSet" type and the
    "System" type's "sca_npr_types" attribute; their role of declaring the
    2 types 'Int' and 'String' will now be handled by the "SysSpecTypeSet"
    type and "special_types" attribute.

    * (Routines_Catalog.pod)  Refactored the 2 pod sections "Procedures For
    Defining (Routines|Data Types)" into 2 alternate pod sections
    "Procedures For Defining (Depot|Package) Routines and Data Types";
    there were no changes to the 8 there-declared procedures themselves.

    * (Basics.pod, Types_Catalog.pod, Routines_Catalog.pod)  Added new
    language concept of "topic namespaces", which is analagous to the
    frequently used SQL DBMS (or general purpose language) concept of a
    "current database|schema" (or current class etc).  In Basics.pod, added
    new primary namespace "tpc" ("topic"), and added new pod sub-section
    under "ENTITY NAMES" called "Time-Varying Topic Namespaces" which
    explains the new feature. In Types_Catalog.pod, added new data type
    "sys.std.Core.Type.Cat.TopicNSControlCat" (for "tpc.cat") in new main
    pod section "TYPES FOR DEFINING TOPIC NAMESPACE CONTROLS".  In
    Routines_Catalog.pod, added new procedure
    "sys.std.Core.Cat.select_topic_namespaces" in new pod sub-section
    "Procedures For Defining Topic Namespaces"; also updated the previously
    existing 12 "create|drop" procedures for in-depot namespaces and
    routines and types so they no longer have explicit parent
    namespace-specifying parameters; instead, users must now set an
    appropriate topic namespace before invoking any of those "create|drop"
    routines, as the topic namespace now is the implicit topic namespace of
    the entity to create|drop.

    * (HDMD_Perl(6|5)_Tiny.pod)  Reorganized some pod sections, but did not
    make any language changes.  Merged the 2 pod main sections "CORE
    GENERIC NONSCALAR VALUES" and "QUASI- VALUES" into the 1 "GENERIC
    Q/SCALAR AND Q/NONSCALAR VALUE LITERALS", which also had the
    "sys.std.Core.Type.Scalar" sub-section moved to it; quasi and non-quasi
    variants of the same node kind are now described together.  Merged the
    2 pod main sections "CORE GENERIC SCALAR VALUES" and "CATALOG SCALAR
    VALUES" into the 1 "SIMPLE CORE SCALAR VALUE LITERALS".  Merged the 2
    "Instant" pod sub-sections into one.  Moved the 2 "BOOTLOADER" sections
    downward to just previous of the "PRAGMAS" section.  Renamed the 2
    "EXTENSION" main sections to replace "VALUES" with "VALUE LITERALS".

    * (PTMD_Tiny.pod, HDMD_Perl(6|5)_Tiny.pod)  Renamed the concept
    "bootloader imperative routine call" to "bootloader statement"; the
    corresponding node kind was renamed from "boot_call" to "boot_stmt";
    the main pod section for it was likewise renamed.

    * (PTMD_Tiny.pod)  Added pod main section "MULDIS D TINY DIALECT
    PRAGMAS" which is simply a clone of the one in HDMD_Perl(6|5)_Tiny.pod;
    in any event, that whole section as we know it now is deprecated.

    * (PTMD_Tiny.pod)  Refactored some grammar tokens, but did not make any
    language changes.  Split "language_name" into itself and
    "ln_base_name"; renamed "ln_authority" to "ln_base_authority", and
    "ln_version" to "ln_base_version_number".  Renamed "literal" to
    "value".  Renamed "val_(node|payload)_elem_sep" to
    "value_(node|payload)_elem_sep".  Renamed all "foo_or_qv" tokens to
    "qfoo".  Changed any "[Q]?" grammar fossils to "Q?".

    * (PTMD_Tiny.pod)  Reorganized all the grammar tokens and code
    examples, but did not make any language changes.  The old 2 pod main
    sections "GRAMMAR OF TINY PLAIN TEXT MULDIS D" and "EXAMPLES" were
    replaced with 8 main sections having 22 sub-sections, of which 7 / 22
    correspond directly to those same-named in HDMD_Perl(6|5)_Tiny.pod (1
    "LANGUAGE NAME", 4 "VALUE LITERALS", 2 "BOOTLOADER); the 8th new main
    section was "VALUE LITERAL COMMON ELEMENTS".  Following this change,
    all Tiny.pod files now keep related grammar and code examples together.

    * (PTMD_Tiny.pod)  Fleshed out the "VALUE LITERAL COMMON ELEMENTS" pod
    main section, so that it now supersedes the kind of information in the
    "GENERAL STRUCTURE" section of HDMD_Perl(6|5)_Tiny.pod; the latter will
    be stripped later.  Cloned and split the "value" token into itself plus
    the 2 new "value_kind" and "payload" tokens; there are now 2 versions
    of "value" in this section, showing things from different angles.  Also
    split the 3 tokens "(bool|order|rat_round_meth)" into themselves and 3
    additional "(bool|order|rat_round_meth)_payload".

    * (PTMD_Tiny.pod)  Added example code to the "BOOTLOADER" section which
    mimics the corresponding example code in HDMD_Perl(6|5)_Tiny.pod.

    * Incremented all copyright year range-ends to 2009.

2008-12-27  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.56.0 is released on CPAN as
    Muldis-D-0.56.0.tar.gz.

    * This release features a snapshot of progress in rewriting the 3
    Muldis D dialect definitions so that, on completion of the rewrite, the
    Tiny Plain Text Muldis D dialect is now treated as the primary one,
    having the primary details and being self-sufficient, and the 2 Tiny
    Perl Hosted Data dialects are then delta documents of that one; prior
    to the rewrite, the reverse was true.  This rewrite is expected to be
    completed over the next 1-2 releases.

    * (PTMD_Tiny.pod, HDMD_Perl(6|5)_Tiny.pod)  Rewrote most of the
    DESCRIPTION pod sections for each of the 3 files, and added a new
    GENERAL STRUCTURE main section to PTMD_Tiny.pod.  Also added a brief
    main pod section REWRITE PROGRESS MARKER to all 3 files to demark
    approximately the post-rewrite from pre-rewrite content.  There wasn't
    really anything removed or altered yet save the DESCRIPTION sections.

    * (Basics.pod)  Added TODO note in TYPE SYSTEM that a feature akin to
    Perl 6 roles, which could be used to provide a quasi-"specialization by
    extension" language feature, might be added in the future.

    * (Basics.pod)  Made various smaller edits to the TYPE SYSTEM main and
    sub-sections, for clarity or to further clean up the results of the
    quasi- made supertypes thing.  Updated the concept of 'scalar type' to
    say that not just a minimum of one but rather all of the possreps of a
    scalar may have only non-quasi attributes.  The concepts 'tuple type'
    and 'relation type' have been tightened to mean exactly what TTM says;
    all nonscalar types have fully-defined attribute lists; the ['Tuple',
    'Database', 'Relation', 'Array'] etc types are now actually
    quasi-nonscalar types even though all their values are non-quasi
    nonscalar.  The concept of 'remnant type' has been restricted to just
    mean a type drawing values from at least 2 of sca/tup/rel/ref; other
    prior uses of 'remnant type' such as for combinations of 'incompatible'
    tuple or relation values are now simply quasi-tuple or quasi-relation
    types instead; also removed the "Remnant Types" pod sub-section.

    * (Basics.pod)  Updated the TYPE SYSTEM main section to say that Muldis
    D now *does* enforce single MSTs for q/scalar types, just between those
    that declare possreps.  While Muldis D doesn't require this to absolve
    ambiguity in general, it simply seemed like a good idea, and targeted
    the main kind of circumstance that TTM cares about with its MST rule.

    * (Types.pod)  A couple small pod format fixes.

    * (Basics.pod, Types.pod, Routines.pod, Types_Catalog.pod)  Reduced any
    mentions of the concepts 'complete type' and 'incomplete|parameterized
    type'.  Also, now only quasi-nonscalar types can be incomplete, and
    also now just the sys-def types that don't list any attributes, like
    'Database', are called incomplete; by contrast, 'Array' and such are
    now called 'complete' (declaring all attrs, even if 'value' is
    'Universal').  Also updated the 'InnerScalarType' and 'InnerRestrType'
    type descriptions concerning what you can or can't use to define an
    incomplete type with.

    * (Routines.pod, QTuple.pod, QRelation.pod)  Added some basic value
    introspection functions which could be used in definitions of generic
    union or restriction types that aren't defined in terms of attribute
    lists, including the system-defined 'Relation' etc which are now
    defined in terms of 'QRelation' etc.  In Routines.pod, added the 5
    functions "sys.std.Core.QScalar.(has_possrep|possrep_names)" and
    "sys.std.Core.QScalar.(degree|has_attrs|attr_names)"; between
    QTuple.pod and QRelation.pod, added the 4 functions
    "sys.std.Q(Tuple|Relation).(has_attrs|attr_names)".

    * (Routines.pod)  Updated the 2 functions
    "sys.std.Core.QScalar.(|update_)attr" to make the 'name' parameter
    optional; like 'possrep', its argument defaults to the empty string if
    not given.  This seemed like a good idea since a lot of built-in
    scalar-with-possrep types have a single attribute per possrep with the
    empty name, and many simple user-def ones likely would also.

    * (Basics.pod, Types.pod)  Added new generic reference type C<External>
    (a proper subtype of C<Reference>) to which belong any black-box values
    that result when a peer or host language, like Perl, wants to hand off
    any arbitrary value or object to Muldis D to hold onto for awhile, such
    as if Perl wants to organize arbitrary things in relations; those
    values are disjoint from all native-to-Muldis D values; these values
    are only transient and can't be kept in a database.

2008-12-19  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.55.0 is released on CPAN as
    Muldis-D-0.55.0.tar.gz.

    * This release features the first rough cut of a reorganization of the
    Muldis D type system such that the quasi-(scalar|tuple|relation) types
    are now proper supertypes of the scalar|tuple|relation types, rather
    than the 2 groups being disjoint yet very similar.  As part of this
    change, all of the generic scalar|tuple|relation operators have been
    made more liberal so to handle the quasi- supertypes natively; but
    their behaviour is unchanged when given arguments that were valid
    before, so these changes are essentially backwards compatible.

    * (PTMD_Tiny.pod, HDMD_Perl6_Tiny.pod)  Fixed a few fossils.  In
    PTMD_Tiny.pod it was a grammar syntax error; in HDMD_Perl6_Tiny.pod it
    was an out-dated code example.

    * (Basics.pod, Routines.pod, Types_Catalog.pod)  Fixed one fossil per
    file regarding the declared type of 'assuming' parameters; each one
    said the parameter was a tuple but it has actually been a quasi-tuple
    for awhile now.

    * (Types.pod, Integer.pod, Blob.pod, Rational.pod, Temporal.pod)  Fixed
    all occurrences of the common documentation/grammar error in type
    definitions that said "a/an <foo-type> is a subtype of <bar-type>" by
    removing the leading "a/an"; the "a/an" designates a value, where we
    wanted to designate a type.

    * (QRelation.pod)  Added new updater "sys.std.QRelation.assign_empty"
    which is analagous to a SQL "TRUNCATE" statement.

    * (Types.pod, Basics.pod, Routines.pod, Types_Catalog.pod,
    PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod, Ordered.pod, QSet.pod,
    QRelation.pod, QArray.pod, QBag.pod)  In Types.pod, renamed all 12
    Quasi- type declarations
    "sys.std.Core.Type.Quasi(Scalar|ScalarDVPT|Tuple(|D0)|Relation(|D0))"
    and "sys.std.Core.Type.Quasi(Set|Maybe|Nothing|Single|Array|Bag)",
    replacing the "Quasi" prefix with "Q".  In all 12 files,
    correspondingly updated all references to those types.

    * (Types.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod)  Deleted the 4
    core types
    "sys.std.Core.Type.Q(ScalarDVPT|(Tuple|Relation)D0|Nothing)", and their
    corresponding special Tiny literal syntaxes.  Renamed the text-Tiny
    token "nothing_or_qv" to "nothing".  Updated the QScalar type
    declaration to not give a default value, giving it one is TODO next.

    * (Basics.pod)  Multiple updates to the TYPE SYSTEM main pod section.
    The 'Tuple' and 'Relation' types are no longer primitives but rather
    are now enumerations, of 'QTuple' and 'QRelation' values.  Under "Type
    Identification": Non-ref type system values are now all in 3 disjoint
    categories rather than 6, the 3 quasi- ones, with the 3 non-quasi now
    being subsets rather than disjoint.  Renamed the "Scalar Types" pod
    section to "Q/Scalar Types", the "Tuple Types and Relation Types" pod
    section to "Q/Tuple Types and Q/Relation Types", and the "Quasi- Types"
    pod section to "Distinction of Quasi- Types from Non-Quasi Types".

    * (Basics.pod)  Completely rewrote the previous-mentioned
    "Distinction..." section, so it now defines non-quasi types in concise
    terms of quasi- types plus a simple restriction ... the distinction is
    that with non-quasi types you can recursively ungroup/unwrap all
    attributes down to scalars, whereas with other quasi- types you can't.

    * (Types.pod)  Merged the 4 main documentation sections "SYSTEM-DEFINED
    CORE (|QUASI-)(|NON)SCALAR PARAMETERIZED DATA TYPES" into the 2 main
    documentation sections "SYSTEM-DEFINED CORE QUASI-/(|NON)SCALAR
    PARAMETERIZED DATA TYPES" and arranged all the type declarations such
    that each 2 similarly named (one quasi-, one not) types appear
    together, the parent quasi- type first.  Within each pair, the quasi-
    parent type now contains most of the descriptive details the pair has
    in common, and the non-quasi one now specifies it is a proper subtype.
    Also reorganized the TYPE SUMMARY documentation section to reflect the
    new type hierarchy.  Also updated the QScalar type declaration to say
    its default value is now the same as Scalar and Bool.

    * (Types_Catalog.pod)  Updated the TYPE SUMMARY pod section to add the
    3 nodes Q(Scalar|Tuple|Relation) to the tree between Universal and
    Scalar|Tuple|Relation.  Also updated the description of the
    'special_types' attribute of the 'System' catalog type to remove
    'Scalar|Tuple|Relation' from the list, leaving just 11 items; said 3
    types will instead be declared under the 'types' attribute of 'System',
    as they now have a type definition format like what users can declare.
    Also updated any mentions, in various catalog entity descriptions, of
    tuple|scalar|relation values or types to add the prefix "q/" where
    either those or their more general quasi- types are applicable.

    * (Types_Catalog.pod)  Updated these 6 catalog types to remove each
    type's "is_quasi" boolean/maybe-of-bool attribute: "SysScaNPRTypeSet",
    "(ScaPR|Tup|Rel)LitExprNodeSet", "Inner(S|Nons)calarType".  In the case
    of "SysScaNPRTypeSet", there are no longer any system-defined
    no-possrep types that aren't scalar.  As for the rest, whether they are
    non-quasi or not will be determined by looking at each type's
    attributes' type definitions, essentially the same work as is done with
    union etc types.

    * (Integer.pod, Blob.pod, Rational.pod, Temporal.pod, Spatial.pod)  In
    these, the 5 language extension files that declare data types, updated
    each file's TYPE SUMMARY pod section to add the single QScalar node to
    the tree between Universal and Scalar; in just Rational.pod, also added
    the single QTuple node between Universal and Tuple.

    * (Routines.pod, Ordered.pod, QTuple.pod, QRelation.pod, QSet.pod,
    QBag.pod, QArray.pod)  Updated all the generic relational operators and
    other generic scalar or nonscalar operators to gain savvy with the
    wider quasi- versions of the types they handled before.  These still
    have the same semantics as before with non-quasi values that worked
    before.  Generally speaking, any declared result or parameter types of
    "Scalar|Tuple|Relation|Set|Maybe|Single|Array|Bag" have now been
    changed to "QScalar" etc; also, all declared result or parameter types
    of "ScaTupRel" have been changed to "Universal".  (So the "ScaTupRel"
    type is no longer used in any system-defined entity signatures, but it
    continues to be declared for the convenience of user-defined entities.)
    Also any "(set|maybe|single|array|bag)_of" type prefixes attached to a
    now-Q-type result or parameter type declaration have been changed to
    "quasi_\w+_of" versions.

    * (Routines.pod, QTuple.pod, QSet.pod, QAarray.pod, QBag.pod,
    QRelation.pod) Related to the previous changes, to make their names
    more accurate, 15 routines were renamed to
    ["sys.std.Core.QScalar.(QTuple_from_QScalar|QScalar_from_QTuple)",
    "sys.std.Core.QRelation.(QTuple_from_QRelation|QRelation_from_QTuple)",
    "sys.std.QTuple.(attr_from_QTuple|QTuple_from_attr)",
    "sys.std.QBag.QSet_from_(wrap|attr)",
    "sys.std.QArray.(QArray_from_(wrap|attr)|limit_of_QArray_from_wrap)",
    "sys.std.QBag.(QSet_from_QBag|QBag_from_(QSet|wrap|attr))"] from the
    same names but lacking any "Q".

    * (Routines.pod)  Updated the descriptions of the 2 routines
    "sys.std.Core.QRelation.un(wrap|group)" to specify that they would fail
    with certain quasi-relation arguments due to their TVAs or RVAs not
    having consistent attribute sets (a problem that non-quasi relations
    never have, by definition).

    * (Routines.pod, QSet.pod, QArray.pod)  Updated the descriptions of the
    8 routines
    ["sys.std.Core.QRelation.(is_(member|subset)|difference|join)",
    "sys.std.QSet.is_member",
    "sys.std.QArray.(update_value|insertion|is_element)"] so that they now
    warn rather than die on type incompatabilities of input relations that
    would make the routine result in a general quasi-relation rather than a
    relation.  Note that there might be other routines needing similar
    documentation updates, but the above 8 were the only ones easily
    locatable by their use of the word "incompatible".  In fact, most
    routines were simply silent on the matter, the behaviour being implied.

    * (Core.pod, Routines_Catalog.pod, Conventions.pod)  Minor entity
    description updates re quasi-/non merge.

2008-12-16  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.54.0 is released on CPAN as
    Muldis-D-0.54.0.tar.gz.

    * This release features the first rough cut of a split in the Perl
    Hosted Data Muldis D dialect into separate versions for Perl 6 and Perl
    5 where each is optimized for its mutually very distinct host, making
    heavy use of features from one version that aren't in the other.  Or
    technically, the split was largely done in release 0.53.0, where
    HDMD_Perl_Tiny.pod gained disjoint descriptions between Perl 6 and Perl
    5 hosts for almost everything; this current release mainly just
    separates those into distinct files.

    * (HDMD_Perl6_Tiny.pod, HDMD_Perl5_Tiny.pod, D.pm, Basics.pod,
    Types.pod, PTMD_Tiny.pod, README)  Cloned the 1 file HDMD_Perl_Tiny.pod
    once and renamed the original and copy into HDMD_Perl(6|5)_Tiny.pod
    respectively.  Updated each copy so it excludes the details not
    relevant to its now single host language, and further tweaks the
    remaining more generic text to become more specialized.  Updated all
    other distro files that referred to the old 1 file so they refer to the
    new 2 instead.

    * This release also has the first step of rearranging the Muldis D type
    hierarchy to make the quasi- types into proper supertypes of their
    non-quasi namesakes, rather than disjoint but similar types.  The
    primary change now is renaming some files, but otherwise leaving
    related changes minimal; the main changes will be done in the next
    release, so that it would be easy to diff the important changes without
    having to deal with the complexity of simultaneous file name changes.

    * (QTuple.pod, QRelation.pod, QSet.pod, QArray.pod, QBag.pod, D.pm,
    Core.pod, README)  Renamed the 5 files [Tuple.pod, Relation.pod,
    Set.pod, Array.pod, Bag.pod] to add a 'Q' prefix.  Updated all other
    distro files that referred to the old file names so they refer to the
    new ones instead.

    * (Routines.pod, QTuple.pod, QRelation.pod, QSet.pod, QArray.pod,
    QBag.pod, Basics.pod, Types_Catalog.pod, HDMD_Perl(6|5)_Tiny.pod,
    Ordered.pod)  Renamed all "sys.std.Core.(Scalar|Tuple|Relation).\w+"
    entities to "sys.std.Core.Q(Scalar|Tuple|Relation).\w+", and all
    "sys.std.(Tuple|Relation|Set(|.Maybe)|Array|Bag).\w+" entities to
    "sys.std.Q(Tuple|Relation|Set(|.QMaybe)|Array|Bag).\w+".

2008-12-15  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.53.0 is released on CPAN as
    Muldis-D-0.53.0.tar.gz.

    * (Basics.pod, Types.pod, Types_Catalog.pod, Routines.pod,
    Routines_Catalog.pod, HDMD_Perl_Tiny.pod, Conventions.pod, Ordered.pod,
    Tuple.pod, Relation.pod, Set.pod, Array.pod, Bag.pod, Rational.pod)
    Updated all distro files that referred to catalog types using their
    unqualified name so to remove the 'Cat.' prefix; now the unqualified
    references for all system-defined types are just spelled 'Foo' and the
    catalog types are no longer special case spelled 'Cat.Foo'.

    * (Types.pod, Blob.pod)  In Types.pod, added new proper subtype of
    'Blob' named 'OctetBlob' whose string lengths are a multiple of 8 bits,
    and that subtype added a new possrep 'octets'.  This new subtype is for
    convenience of users since most user Blob values will likely consist of
    whole octets and users would probably like to deal in those terms.
    Also added new 'String' subtype 'OString' in the same file.  In
    Blob.pod, renamed the 2 functions "is_(|not_)_substr" to
    "is_(|not_)_substr_bits" and added the 3 new functions
    "length_in_octets" and "is_(|not_)_substr_octets".

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Fixed a widespread Perl 6
    grammar mistake in PTMD_Tiny.pod; with character classes defined as a
    range between 2 characters, the endpoints of the range are actually
    separated by a double period (which is generic Perl range literal
    syntax), not a single hyphen like in Perl 5.  Likewise updated the
    string format syntax in HDMD_Perl_Tiny.pod.

    * (HDMD_Perl_Tiny.pod)  Renamed the concept "node type" to "node kind",
    to help avoid possible confusion with the concept of a data type name.

    * (PTMD_Tiny.pod)  Renamed the 4 grammar tokens "text_str",
    "(|(|non)quoted_)text_str_seg" to replace any "text" for "char, since
    they're also used for Name and Comment etc.  Renamed the token
    "list_sep" to "list_elem_sep" and "pair_sep" to "pair_elem_sep".  The
    token "scalar_type_name" was merged into "type_name".

    * (Types_Catalog.pod)  Updated the NameChain and DeclNameChain types to
    eliminate their "flat" possreps, leaving just their "array" possreps;
    the concept of a "flat" possrep has been demoted and can now just be
    provided by individual dialects in their proprietary manners instead.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Updated both Tiny dialects to
    simplify the literal formats for NameChain and DeclNameChain values.
    With PTMD_Tiny, you can't put a whole (multi-part) chain in a single
    pair of bracket or quote delimiters anymore; instead, each kind of
    chain is just expressed as a non-delimited chain of period-separated
    Name-formatted elements; only each element can be either a bareword or
    a quote-delimited string; now, literal period characters in chain
    elements are never escaped; now, DeclNameChain are formatted exactly
    the same as NameChain, without any leading/trailing periods.  With
    HDMD_Perl_Tiny, eliminated all Muldis D specific character escaping;
    now, if you want to have literal perod characters in chain elements,
    then you must use the Array payload format; also an empty string in the
    string payload format now means a single-element DeclNameChain; you
    must use the Array payload format to represent a zero-element chain.
    In PTMD_Tiny, merged the 5 grammar tokens "(|d)nc_(array|flat)" and
    "nc_char" into the 2 "(|decl_)name_chain_body" and then merged the 2
    grammar tokens "text_(delim|char)" into the 1 "quoted_char_str_seg".

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Further standardized the formats
    and generic features of Muldis D value literals in both Tiny formats so
    that literals are more intuitive to write and easier to parse or
    generate.  Now, every value literal has 1-3 main parts, which are the
    node kind, a usually optional type name, and a usually mandatory
    payload.  Previously, most scalar typed literals didn't take an
    (optional) explicit subtype name like nonscalar typed literals did, but
    now they do.  Any old 1+ main literal parts besides the node kind and
    optional type name are now all collectively part of the payload under
    the new design.  In PTMD_Tiny, the 'spec_sep' token has been split into
    the 2 tokens 'val_(node|payload)_elem_sep', the first new one being a
    colon character like the old one, and the second new one being a
    semicolon character; the first new one is used to separate the 1-3 main
    parts of a value literal, and the second is used to separate any
    multiplicity of payload parts that some payloads might have.  In
    HDMD_Perl_Tiny, the main documentation has been refactored so that the
    GENERAL STRUCTURE pod section now describes the 1-3 main PHMD node
    parts on behalf of all node kinds, and the pod sections specific to
    each node kind have now been simplified to just describe the new
    payloads; where the old PHMD node had just 1 element besides node kind
    and optional type name, the new payload is exactly the same; where the
    old PHMD node had possibly multiple (typically 1 or 2) elements besides
    the node kind and type name, the new payload is an Array|Seq having
    those same 1 or 2 elements (the old 'payload' was renamed, typically to
    'main payload'); any further refactoring on this matter is described in
    other change items.  The main PHMD node is an Array|Seq in the general
    case but if a node would have 2 elements (no type name is present),
    then in Perl 6 there is now the option to use a Perl 6 Pair for the
    PHMD node instead.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Updated PTMD_Tiny to support an
    alternative more terse syntax for base-10 numeric literals; you can now
    write a numeric literal without an explicit max-col-val specifier,
    which is interpreted the same as an explicit max-col-val of '9'
    (HDMD_Perl_Tiny already supported this terse form before).  Both Tiny
    files had their examples updated to use the terse syntax for literals
    that were explicitly base-10 before.  Also added a couple more 'Rat'
    examples in PTMD_Tiny.

    * (PTMD_Tiny.pod)  Refactored all the tokens denoting value literals so
    that the payload portion is always apart from the main portion, and
    further standardized naming for already existing such splits.
    Reorganized the 4 tokens ["relation_or_qv",
    "generic_relation_(empty_body|(|non)ordered_attr)_or_qv"] into the 6
    tokens ["(|generic_)relation_or_qv",
    "generic_relation_(|empty_body|(|non)ordered_attr)_or_qv_payload"].
    Renamed the 2 tokens "(tuple|bag)_body" to "(tuple|bag)_or_qv_payload".
    Split each of these 12 tokens into itself and a same-named but for a
    "_payload" suffix: "scalar_or_qv", "int", "string", "blob", "text",
    "set_or_qv", "single_or_qv", "array_or_qv", "comment", "rat",
    "instant", "duration".  Renamed each of these 2 tokens to change the
    "body" to "payload": "name_body", "name_chain_body".

    * (HDMD_Perl_Tiny.pod)  Forked every "Examples:" section into 2
    adjacent "Perl 6|5 Examples:" sections, with each version having
    identical-meaning code but with greater savvy for distinct host
    language features.

    * (HDMD_Perl_Tiny.pod)  Updated the value literal payload formats for
    the 3 types [Bool, Order, RatRoundMeth] so that the Perl 6 and Perl 5
    descriptions are now disjoint.  Perl 6 has been restricted so that now
    the only way you can specify 'Bool' and 'Order' payloads is with their
    Perl 6 native counterparts, which are 'Bool' and 'Order' objects; you
    can no longer specify such payloads as Perl 6 Int or Str objects; so a
    PTMD_Tiny parser in Perl 6 will now have to do more than tokenize to
    Str objects.  In Perl 5 you still have all the options you did before,
    and these are now spelled out more clearly; you can still use all the
    canonical or typical Perl 5 forms of those values, plus the string
    results of a PTMD_Tiny parser in Perl 5.  Since 'RatRoundMeth' has no
    native equivalent types in either Perl version, you still use Str
    objects or char string scalars as before.

    * (HDMD_Perl_Tiny.pod)  Updated the value literal payload formats for
    the 7 types [Int, String, Blob, Rat, (UTC|Float)Instant, Duration] so
    that the Perl 6 and Perl 5 descriptions are now disjoint.  Perl 6 has
    been restricted so that now the only way you can specify 'Int' and
    'Blob' and 'Rat' payloads is with their Perl 6 native counterparts,
    which are 'Int' and 'Blob' and 'Rat|Num|Int' objects; you can no longer
    specify such literals as Perl 6 Str objects, or specify Rat payloads as
    a collection of Int components; for all 7 types, you can no longer use
    'Str' objects plus max-col-val meta-data to get the Muldis D
    implementation convert the results from a PTMD_Tiny tokenizer, but
    rather you must now use the native facilities of Perl 6 to support
    denoting numeric literals in any base from 2 thru 36; Perl 6 can do the
    text-to-num mapping for you, and Perl 6's native numbers are "big".  In
    Perl 5 you still have all the options you did before, and these are now
    spelled out more clearly; you can still use all the canonical or
    typical Perl 5 forms of those values, plus the string results of a
    PTMD_Tiny parser in Perl 5.  One large further change in Perl 5 is that
    you now use a 1-element hash ref to group a max-col-val (the key) with
    the main payload it is meta-data for (the value); this is instead of
    using a 2-element array ref; this change was made so that one could
    disambiguate 'Rat' payloads like "['2', '11001001']" (is the first
    element a max-col-val or a numerator?) without using messy further
    array nesting; it was done with all max-col-val possibly using types
    for consistency and to allow further simplification and elegance.  Note
    that it is expected the actual use of max-col-val would be infrequent,
    so huffman coding with the 'slower'/'fatter' hash refs is justified.

    * (HDMD_Perl_Tiny.pod)  Updated the value literal payload formats for
    the 5 types [Text, (|Quasi)Tuple, (|Quasi)Array] so that the Perl 6 and
    Perl 5 descriptions are now disjoint.  There aren't any actual changes
    or restrictions here, just clarifications.

    * (HDMD_Perl_Tiny.pod)  Updated the value literal payload formats for
    the 4 types [(|Quasi)Set, (|Quasi)Bag] so that the Perl 6 and Perl 5
    descriptions are now disjoint.  Perl 6 has been restricted so that now
    the only way you can specify 'Set' and 'Bag' payloads is with their
    Perl 6 native counterparts, which are 'Set|KeySet' and
    'Bag|KeyBag|Set|KeySet' objects; you can no longer specify such
    literals as single or nested Perl 6 Seq|Array objects.  In Perl 5 you
    still have the same options you did before (namely single or nested
    array refs), and these are now spelled out more clearly.

    * (HDMD_Perl_Tiny.pod)  Updated the value literal payload formats for
    the 2 types "(|Quasi)Scalar" so that the Perl 6 and Perl 5 descriptions
    are now disjoint.  In Perl 6, the 2 elements of the payload (possrep
    name and possrep attrs) are now wrapped up in a Perl 6 Pair rather than
    a Seq|Array.  In Perl 5, a 2 element array ref is still used.

    * (HDMD_Perl_Tiny.pod)  Updated the value literal payload formats for
    the 2 types "(|Quasi)Relation" so that the Perl 6 and Perl 5
    descriptions are now disjoint.  In Perl 6, every payload now must be
    either a Perl 6 Pair (ordered attrs format) or Set (named attrs
    format), and can't be a Seq|Array like before; also, the value element
    of that Pair must likewise be a Set; so now every part of the literal
    that was conceptually unordered now actually is.  In Perl 5, array refs
    are still used like before.

2008-11-29  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.52.0 is released on CPAN as
    Muldis-D-0.52.0.tar.gz.

    * As of this release, all (non-archive) versioned files have had their
    version numbers increased to match the version number of the release
    itself, or in other words, to match the version number of D.pm; from
    now on, all file versions will increment in lockstep regardless of
    whether any actual (other) changes were made to the files in question.
    This means that the meaning of the file version numbers has changed
    from treating each file as a distinct document whose progress is
    tracked, to being a component of the Muldis D language spec as a whole,
    such that if any file is seen in isolation, it can more easily be
    matched up with other files that form parts of the same Muldis D
    language spec version.  This also makes further updates to the spec
    easier since managing many distinct version numbers was a lot more work
    and error-prone; examples of such errors were that the previous 2
    releases (50 and 51) both forgot to increment their changed .pod files'
    internal versions like the Changes file of those releases said they
    were.  To see what actual changes were made to files, the individual
    change items still will list them as they did before.

    * (D.pm, Basics.pod, Types.pod, Routines.pod, PTMD_Tiny.pod,
    HDMD_Perl_Tiny.pod, Integer.pod, Blob.pod, Text.pod, Tuple.pod,
    Relation.pod, Array.pod, Bag.pod, Rational.pod, Temporal.pod)  Updated
    all the standard references to numbers that are zero or greater so they
    are referred to as "non-negative" rather than "unsigned".  Renamed the
    2 generic data types "U(Int|Rat)" to "NN(Int|Rat)" and the 3
    Temporal.pod specialty data types "UInt(23|59)" and "URatLT62" to
    "NNInt(23|59)" and "NNRatLT62".  A few plain-text Tiny grammar tokens
    were likewise renamed, from a "u" prefix to a "nn" prefix.

    * (Types.pod, Types_Catalog.pod)  Minor misc fixes.

2008-11-29  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.51.0 is released on CPAN as
    Muldis-D-0.51.0.tar.gz.

    * This release serves mainly to add a new conceptually lower level
    abstraction layer to the Muldis D type system such that the (unlimited
    size) integer is now the only primitive scalar type, and all other
    types are now explicitly defined just in terms of integers, directly or
    indirectly.  This release's changes are fully backwards compatible,
    only adding features; the 2 exceptions being that certain subtleties of
    character strings have changed, and a bit about reference types.

    * New file versions are: D.pm 0.51.0 and Types_Catalog.pod 0.36.0 and
    Routines.pod and PTMD_Tiny.pod 0.32.0 and Basics.pod and Rational.pod
    0.30.0 and HDMD_Perl_Tiny.pod 0.29.0 and Integer.pod and Blob.pod
    0.28.0 and Types.pod and Text.pod 0.27.0 and Temporal.pod 0.10.0.  The
    other pre-existing versioned files are unchanged.

    * (Basics.pod, Types.pod, Text.pod)  Updated the definition of
    character strings and the 'Text' data type (and indirectly, 'Name',
    'Comment', etc) to explicitly say that Muldis D works at the Unicode
    codepoint abstraction level, not the grapheme abstraction level, so
    what codepoints comprise a grapheme are significant for value identity.
    This change was made to make Muldis D simpler to define in isolation
    and more future-proofed and deterministic etc, and easier to extend
    such as for locale-specific things, versus the undefined 'highest
    possible' abstraction level it previously had.  In Text.pod, added new
    function 'length_in_codepoints' to complement the existing
    'length_in_graphemes', and changed the exact meaning of the latter;
    also added the 2 new functions 'folded_to_NF(C|D)' (to be generified
    later), which you would use if you want to effectively work at the
    grapheme abstraction level.

    * (Basics.pod, Types.pod, Types_Catalog.pod)  Added new union type
    'sys.std.Core.Type.Reference' that is disjoint from all the
    non-'Remnant' types, and updated the 4 'Func|Proc|Type|OrdDetFunc)Ref'
    types so they are now in this new category and are no longer in the
    quasi-scalar category (which now has no system-defined non-DVPT types).

    * (Types.pod, Types_Catalog.pod, Routines.pod, PTMD_Tiny.pod)
    Redefined the Bool core type so that rather than having zero possreps,
    it now has 2: 'name' (a Name) with values ['false', 'true']; 'int' (an
    Int) with values [0, 1].  Also updated the plain-text Tiny dialect so
    that '0' and '1' are now acceptable Bool literals along with 'false'
    and 'true' (no change was needed in HDMD_Perl_Tiny.pod as it already
    supported 0|1).  So Bool is now defined structurally and syntax-wise in
    the same way as Order.

    * (Types.pod, Types_Catalog.pod)  Redefined the QuasiScalarDVPT core
    type so that rather than having zero possreps, it now has 1, with zero
    attributes.

    * (Types.pod, Types_Catalog.pod, Routines.pod, PTMD_Tiny.pod,
    HDMD_Perl_Tiny.pod)  Added new core scalar type
    'sys.std.Core.Type.String', which has zero possreps; a String is
    defined as a dense sequence of 0..N (unlimited size) integers,
    similarly to the primitive string types of many programming languages;
    unlike Array, String is *not* defined over a Relation and its elements
    can only be integers.  Updated the 2 Tiny dialects so they gain special
    literal syntax for String values.

    * (Types.pod, Types_Catalog.pod, Routines.pod)  Added new core subtype
    'BString' (bit string) of String where each element must be between
    zero and 1, and redefined the Blob core type so that rather than having
    zero possreps, it now has 1, and Blob is now simply a wrapper over
    BString having a different intended interpretation.

    * (Types.pod, Types_Catalog.pod, Routines.pod)  Added new core subtype
    'UCPString' (Unicode codepoint string) of String where each element
    must be between zero and 0x10FFFF, and redefined the 3 core types
    Text|Name|Comment so that rather than having zero possreps, each now
    has 1, and each of Text|Name|Comment is now simply a wrapper over
    UCPString having a different intended interpretation.

    * (Basics.pod)  Made some large additions and changes to the TYPE
    SYSTEM main documentation section of Basics.pod, primarily to declare a
    new parallel type categorization system, wherein every Muldis D type is
    just one of these 4 kinds, depending on how the type is defined:
    primitive type, structure type, enumeration type, reference type.  Also
    the definition of a root type (and nonroot type) has been restated in
    terms of these categories, which should be a lot more understandable.

    * (Types.pod, Types_Catalog.pod, Integer.pod, Blob.pod, Rational.pod,
    Temporal.pod)  Annotated all the Muldis D data type definitions, either
    individually or by documentation section, to say which of the above 4
    categories each one belongs to.

2008-11-08  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.50.0 is released on CPAN as
    Muldis-D-0.50.0.tar.gz.

    * New file versions are: D.pm 0.50.0 and PTMD_Tiny.pod 0.31.0 and
    HDMD_Perl_Tiny.pod 0.28.0.  The other pre-existing versioned files are
    unchanged.

    * (D.pm)  In the VERSIONING section, clarified that a Muldis D language
    name can have some elements optional in documentation, in which case
    the partial name refers to the whole subtree of language variants
    having the specified elements in common.  Also simplified the
    Extensions sub-section to say that whether a 5th or subsequent elements
    exists and their format varies by the dialect in use.

    * (HDMD_Perl_Tiny.pod)  Simplified all value literals having an
    'any_perl' format hint option, namely
    Bool|Int|Rat|(UTC|Float)Instant|Duration, by removing said option.  So
    now the most liberal Perl-specific format options are gone; however,
    the more strict Perl-specific formats (that disallow whitespace for
    example) that remain now allow a few more options than before.  A
    perl-bool in Perl 5 may now use either the number zero or the empty
    string to mean false, not just the empty string.

    * (HDMD_Perl_Tiny.pod)  Simplified all value literals having a format
    hint portion, namely
    Bool|Int|Blob|Order|Rat|(UTC|Float)Instant|Duration, by removing said
    format hint portion.  With the numeric, blob, and temporal value
    literals, the test for how to interpret the payload is based simply on
    the number of node elements, which is 3 for md and 2 for perl, and the
    old 3rd/4th format element was redundant now that any-perl no longer
    exists.  With bool and order types, that are both very short enums, we
    can unambiguously determine what bool/order value was wanted by
    examining the Perl data type and Perl values of the payload.  Overall,
    this change should eliminate another kind of tedious verbosity that was
    common to Perl-Tiny code.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  In a reversal of one aspect of
    release 0.20.0, updated most nonscalar value literal syntax to re-add
    the then-removed explicit meta-data of what specific data type the
    nonscalar value is a member of, rather than it for example being a
    generic relation value.  But use of this meta-data is now optional
    rather than mandatory like in its previous incarnation.  Also removed
    the 'treat_as_type' lexical pragma, which is now redundant.

2008-10-07  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.49.0 is released on CPAN as
    Muldis-D-0.49.0.tar.gz.

    * New file versions are: D.pm 0.49.0 and PTMD_Tiny.pod 0.30.0 and
    HDMD_Perl_Tiny.pod 0.27.0.  The other pre-existing versioned files are
    unchanged.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  In PTMD_Tiny.pod, updated
    numeric-based literals to permit use of the underscore character as a
    separator, which may make long numbers easier to read (eg
    Int:1_000_000_000); in HDMD_Perl_Tiny.pod, made the same change
    concerning 'md_\w+' formats of numeric-based literals.  Note that
    concerning 'perl_\w+' formats, Perl already has this support built-in.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  In a reversal of one aspect of
    release 0.20.0, there is no longer special terse
    syntax for 'Name' literals appearing in the position of a generic
    literal; the general syntax for 'Name' literals / PHMD nodes is now
    exactly the same as for 'Text' or 'Comment', such as "Name:'foo'" and
    "[ 'Name', 'foo' ]" rather than plain "'foo'".  On the other hand,
    'Name' literals appearing in special positions where one is already
    expected, such as nonscalar literal attribute names, are retaining the
    terse syntax there.

    * (HDMD_Perl_Tiny.pod)  Simplified 'Bag' literals by removing their
    format hint portion.  Because 'Name' literals no longer have the
    special Perl Str syntax in generic literal contexts, we can now
    unambiguously interpret a 'Bag' literal payload without an external
    format hint.

    * (PTMD_Tiny.pod)  Simplified the entire grammar by removing all
    capturing parens, and the 'grammar' declaration, that a real grammar
    would have, so the given syntax can be a more clear human illustration.

    * (PTMD_Tiny.pod)  Fixed a widespread Perl 6 grammar mistake;
    non-capturing groups are actually delimited by square brackets, not
    round parenthesis like in Perl 5.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  In PTMD_Tiny.pod, updated the
    grammar for all comma-separated lists so that there now must not be a
    trailing comma after the last list item; previously, a trailing comma
    was mandatory.  Note that there is no corresponding HDMD_Perl_Tiny.pod
    change since trailing commas are always optional in Perl.  Updated all
    PTMD_Tiny.pod code samples to conform to the updated grammar, and
    updated just some HDMD_Perl_Tiny.pod code samples likewise.

    * (PTMD_Tiny.pod)  Refactored grammar for numeric literals, adding the
    2 new tokens 'pint_(head|tail)'.  Also updated numeric literals so that
    they may now be split into segments as per character or bit strings,
    with the '~' segment separator character; useful for very long numbers.

    * (PTMD_Tiny.pod)  Added support for bareword / non-delimited character
    string literals, mainly intended to be used for 'Name' (and NameChain
    etc) literals but also useable for Text and Comment literals.  A
    character string may be used non-delimited iff it is non-empty and only
    consists of the characters [a-zA-Z0-9_-], but allowable bareword
    characters may be expanded later to include anything Unicode considers
    a letter or a number.  Since most DBMS entity names and attribute names
    etc are likely to qualify for bareword syntax, this change helps make
    Muldis D code be easier to write and more like normal languages.  Also,
    the 'PTMD_Tiny' 4th element of its fully qualified language name is now
    always a bareword rather than always a delimited string.

2008-09-18  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.48.0 is released on CPAN as
    Muldis-D-0.48.0.tar.gz.

    * Fixed the version numbers inside the 2 files PTMD_Tiny.pod and
    HDMD_Perl_Tiny.pod; they should have been 0.28.0 and 0.25.0
    respectively in Muldis-D-0.47.0 but were mistakenly not incremented
    like the Changes file of that release said they were.

    * New file versions are: D.pm 0.48.0 and Routines.pod 0.31.0 and
    PTMD_Tiny.pod and Rational.pod 0.29.0 and Integer.pod and Set.pod
    0.27.0 and HDMD_Perl_Tiny.pod 0.26.0 and Temporal.pod 0.9.0.  The other
    pre-existing versioned files are unchanged.

    * Updated the README file to indicate that a new public repository at
    http://github.com/muldis/ is planned for the near future.

    * Updated the Makefile.PL to remove the obsolete warning message about
    a warning message that the POD manifyer might give.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Simplified 'Bag' literals by
    removing their format hint portion when the payload portion would be
    unambiguous without the hint.  In PTMD_Tiny.pod, no hints are necessary
    at all, so removed the ':count' and ':repeat' syntax entirely; then
    refactored the 3 'bag_\w+' tokens into 4 'bag_\w+' tokens.  In
    HDMD_Perl_Tiny.pod, the 'bag' PHMD node type can now have either 2 or 3
    elements; it must now have 2 when the payload is a Perl 6 Bag|KeyBag,
    and it must still have 3 when the payload is an Array|Seq; so the
    'perl_bag' hint is gone, but the 'aoa_counted' and 'array_repeated'
    hints remain (because there is ambiguity between the latter 2 in the
    general case when we have no hint, due to a 'name' node being a Str).

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Simplified 'Rat' literals by
    removing or folding their format hint portion.  In PTMD_Tiny.pod, no
    hints are necessary at all, so removed the ':radix' and ':ratio' and
    ':float' syntax entirely; then refactored the 4
    'rat(|_with_radix|_as_(ratio|float))' tokens into 2 'rat(|_body)'
    tokens.  In HDMD_Perl_Tiny.pod, the format hints were folded from 10 to
    3 as follows: 3 'md_(radix|ratio|float)' became 1 'md_rat', 4
    'perl_(rat|float|int_(ratio|float))' became 1 'perl_rat', 3
    'any_perl(|_(ratio|float))' became 1 'any_perl'; also, the reference to
    a Perl 6 "Float" type (which it doesn't have) was corrected to "Num".

    * (Routines.pod)  Removed the 2 niladic functions
    "sys.std.Core.Bool.(false|true)", which are superfluous given that all
    Muldis D dialects would have a dedicated syntax for Boolean literals,
    which are scalars having no possreps.

    * (Set.pod)  Added new order-determination function
    "sys.std.Set.Maybe.order" which provides a short-hand to defining
    semantics analagous to SQL's "NULLS FIRST|LAST".

    * (Integer.pod, Rational.pod)  Added 2 dyadic functions
    "sys.std.(Integer|Rational).abs_difference", each of which results in
    the absolute difference between its 2 arguments.

    * (Temporal.pod)  As anticipated would be necessary following the
    previous rewrite in release 0.34.0, rewrote the Muldis D Temporal
    Extension again; the most serious issues cited after the previous
    rewrite are now gone.  The temporal data types, and associated
    operators, are now few and generic rather than many and specialized, so
    the combinatorial explosion is gone; the number of distinct types
    dropped from 28 to 14, and routines from 93 to 17.  The 2 previous
    distinct units 'second(|s)' (int), 'fractional_second(|s)' (rat) have
    been merged into the 1 distinct unit 'second(|s)' (rat).  A year zero
    is now supported where it previously wasn't.  The concepts of multiple
    time zones and daylight savings time adjustments are now gone; instead,
    date-time types now just come in 2 kinds, those known to be specific to
    UTC, and those that are floating and not tied to any zone; if you want
    to work with time zones or DST, you must now explicitly convert to/from
    UTC on input and output.  The DESCRIPTION pod received some updates but
    is mostly the same as before.

    * (Temporal.pod)  Rewrote the complement of temporal data types.  In
    summary, the previous 21 temporal scalar root types were replaced by 3
    new temporal scalar root types plus 6 new scalar subtypes.  Each new
    root type declares 1 possrep and each new subtype adds 1 more possrep.
    Each new root type possrep consists of 6 maybes of numerics, so the
    root types can represent arbitrary precision as before, but also
    represent that information on larger units is unknown while in smaller
    units it is known; each subtype says that exactly certain parent
    attributes are known and others are unknown (eg, just YMD or HIS are
    known).  For specifics: 6 '(Date|Time)To(I|S|FS)WithTZ' became 4
    'UTC(Instant|DateTime|Date|Time)', 9
    '(DateTo(Y|M|D|I|S|FS)|TimeTo(I|S|FS))' became 4
    'Float(Instant|DateTime|Date|Time)', 6 'DurationOf(Y|M|D|I|S|FS)'
    became 1 'Duration' (this last one may gain a few subtypes in the
    future).  Regarding the plain numeric subtypes declared by Temporal,
    the 1 'NZInt' was removed and the 2 ['UInt62', 'URatLT1'] were replaced
    by the 1 'URatLT62'; the 4 ['PInt(12|31)', 'UInt(23|59)'] remained
    unchanged.

    * (Temporal.pod)  Rewrote the complement of temporal math functions and
    system services.  In summary, the previous 63 temporal math functions
    and 30 system services were replaced by the new 11 temporal math
    functions and 6 system services.  For specifics: 18
    '(Date|Time)To(I|S|FS)WithTZ.(difference|later|earlier)' became 4
    'UTCInstant.((|abs_)difference|later|earlier)', 27
    '(DateTo(Y|M|D|I|S|FS)|TimeTo(I|S|FS)).(difference|later|earlier)'
    became 4 'FloatInstant.((|abs_)difference|later|earlier)', 18
    'DurationOf(Y|M|D|I|S|FS).(abs|sum|difference)' became 3
    'Duration.(abs|sum|difference)', 6
    'DateTo(I|S|FS)WithTZ.fetch_current_date_(utc|local)' and 6
    'TimeTo(I|S|FS)WithTZ.fetch_current_time_(utc|local)' became 3
    'UTCInstant.fetch_current_(datetime|date|time)', 12
    'DateTo(Y|M|D|I|S|FS).fetch_current_date_(utc|local)' and 6
    'TimeTo(I|S|FS).fetch_current_time_(utc|local)' became 3
    'FloatInstant.fetch_current_(datetime|date|time)'.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Added special syntax for value
    literals of temporal data types, defined in terms of 3 new keywords or
    PHMD node types: 'UTCInstant', 'FloatInstant', 'Duration'; each of
    these is built from an ordered list of up to 6 elements, which are
    numbers (YMDHIS).  Also added 6 new example literals using the new
    keywords/node-types.  Also added an example generic Scalar literal
    showing how to write a temporal value in terms of named/unordered
    components.  Also updated the example of a Single literal to contain
    some other piece of text that isn't a date string.

2008-08-30  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.47.0 is released on CPAN as
    Muldis-D-0.47.0.tar.gz.

    * New file versions are: D.pm 0.47.0 and Routines.pod 0.30.1 and
    PTMD_Tiny.pod 0.28.0 and HDMD_Perl_Tiny.pod 0.25.0.  The other
    pre-existing versioned files are unchanged.

    * (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod)  Renamed the pragma
    "auto_complete" of both Tiny dialects to "auto_add_attrs".

    * (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod)  Added new pragma to both Tiny
    dialects named "auto_unabbrev_std_names", which when turned on lets a
    programmer omit leading chain elements of "Cat.NameChain" literals
    referencing "sys.std"-named types and routines, so long as the
    abbreviated version is unique within that namespace (with an exception
    iff exactly 1 candidate is "sys.std.Core"-named).  So this now makes
    official a kind of optional brevity that was often done with parameter
    data types in routine documentation, though not yet elsewhere, that can
    cut names of types or routines down to a half or sixth of the length
    they would otherwise have.  Almost all of the pod additions were in
    HDMD_Perl_Tiny.pod, as a new sub-section of the "MULDIS D TINY DIALECT
    PRAGMAS" pod at the end; like that file's pod in general, it speaks for
    both Tiny dialects.  The only change in PTMD_Tiny.pod was addition of a
    code sample of a Muldis D language name declaration that turned the
    pragma on.

    * (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod)  Added new pragma to both Tiny
    dialects named "auto_chains_from_names", dependent on the previous 2
    pragmas being turned on, which when turned on lets a programmer write
    an abbreviated-to-a-single-chain-element "Cat.NameChain" literal as a
    terser "Cat.Name" literal.

    * (PTMD_Tiny.pod)  Fixed typos.

    * (Routines.pod)  Removed the placeholder main pod section
    "SYSTEM-DEFINED GENERIC QUASI- FUNCTIONS"; at such point that any
    routines for quasi- types are formally defined, they will just go in
    language extensions rather than the language core.

2008-08-17  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.46.0 is released on CPAN as
    Muldis-D-0.46.0.tar.gz.

    * New file versions are: D.pm 0.46.0 and Types_Catalog.pod 0.35.0 and
    Routines.pod 0.30.0 and Basics.pod 0.29.0 and PTMD_Tiny.pod 0.27.0 and
    HDMD_Perl_Tiny.pod 0.24.0 and Routines_Catalog.pod 0.2.0.  The other
    pre-existing versioned files are unchanged.

    * (Basics.pod, HDMD_Perl_Tiny.pod, PTMD_Tiny.pod)  Bootloader routines
    may now directly reference global variables, and can now invoke any
    kind of imperative routine that has subject-to-update parameters,
    including updaters.  In Basics.pod, updated the 'bootloader' routine
    kind description and made related updates in the ROUTINES main pod
    section.  With both Tiny.pod, updated the grammar and examples for
    boot_call tokens/nodes so they now have distinct subject-to-update and
    read-only arguments.

    * (Types_Catalog.pod)  Removed the partly defined "Cat.DbVar" type,
    which is no longer being used.  Updated the "Cat.(Depot|Package)" types
    to change their "data" attribute to have the "Cat.NameChain" type
    rather than "Cat.DbVar"; now, that attribute just holds the declared
    name of the data type of the dbvar of the depot|package, where the type
    is declared first as its own DBMS entity, or otherwise the declared
    type is simply "Database".  Similarly updated the type of the "catalog"
    attribute of the "Cat.SysCatSet" type to a NameChain from a DbVar.

    * (Basics.pod, Types_Catalog.pod)  It is now optional for a
    depot|subdepot|package to have a self-local dbvar, which should help
    save us from some chicken and egg constraints that come into play when
    one wants to do data definition of depots etc.  In Basics.pod, the
    "User Namespace Correspondence" pod sub-section of "ENTITY NAMES" got
    some large updates.  In Types_Catalog.pod, the data type of the "data"
    attribute of the "Cat.(Depot|Package)" types is now a
    "maybe_of.Cat.NameChain" rather than a "single_of.Cat.NameChain".

    * (Routines.pod)  Added a set of 9 new update operators where each is a
    short-cut over a tuple|relational function plus a generic assignment of
    the function's result to the main relvar argument of the function; a
    subset of these correspond directly to the data-manipulation phase of
    common SQL "CREATE|ALTER|DROP TABLE|VIEW" statements.  These 4 updaters
    were added as "sys.std.Core.Tuple.\w+":
    "assign_(rename|product|(|cmpl_)projection)".  These 5 updaters were
    added as "sys.std.Core.Relation.\w+":
    "assign_(rename|(|static_)extension|(|cmpl_)projection)".

    * (Types_Catalog.pod)  Updated the "Cat.Federation" type by adding a
    third attribute "type_maps", which indicates the various copies of the
    same type over multiple depots, such that the DBMS can then treat those
    types as interchangeable, so to support cross-depot operations.  Also
    added the 2 new catalog types "Cat.FedTypeMap(Set|)" which define that
    new attribute.

    * (Routines_Catalog.pod)  Grouped all the procedures under a new main
    pod section "PROCEDURES FOR BOOTSTRAPPING A MULDIS D PROGRAM OR
    DATABASE", where their old groupings became second-level pod sections.
    Wrote an introduction to this section that outlines what the procedures
    do or don't do, and explains them in the context of what a bootloader
    can directly do and what it can only do indirectly by defining and
    executing other routines.  Removed part of the "DESCRIPTION" as now
    being redundant or outdated.

    * (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod)  Added new/first lexical-scope
    pragma to both Tiny dialects named "treat_as_type", which takes the
    form of a wrapper syntax/PHMD-node that annotates the
    typically-nonscalar child lexical/node with a specific data type.  Used
    alone, this can help with some kinds of compile-time type checking.
    Used together with the "auto_complete" language-name-level pragma, this
    can help determine what names and types of attributes need to be
    auto-added to literals that are otherwise "just a relation|tuple" and
    lack that specific meta-data, such as with argument values for
    bootloader-invoked routines that have "Relation" typed parameters.

    * (Basics.pod, Types_Catalog.pod, PTMD_Tiny.pod)  Fixed typos.

    * (Basics.pod)  Added a few TODO-ish comments in ENTITY NAMES
    sub-sections that any references to
    "sys.cat.(system|impl|mount|foreign|interp)" are out-dated; the actual
    system catalog doesn't mention them, and the catalog also still has to
    be updated to have a place for describing implementation specific
    entities; currently "(sys|mnt).cat" describe just standard entities;
    the out-dated parts are being kept as a reminder of ideas still todo.

2008-08-15  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.45.0 is released on CPAN as
    Muldis-D-0.45.0.tar.gz.

    * New file versions are: D.pm 0.45.0 and Types_Catalog.pod 0.34.0 and
    Basics.pod and Rational.pod 0.28.0 and Types.pod and PTMD_Tiny.pod
    0.26.0 and HDMD_Perl_Tiny.pod 0.23.0 and Routines_Catalog.pod 0.1.0.
    The other pre-existing versioned files are unchanged.

    * (D.pm)  In the "VERSIONING" pod section, updated the description of
    the 5th "Extensions" name part to clarify that name+value entries in it
    could also be pragmas or compiler directives.

    * (Basics.pod)  Updated the "Terse Pseudo-Variable Syntax" sub-section
    of the main pod section "ENTITY NAMES", so it now says that one can
    also use that terse syntax to drill down into attributes of relations,
    but that the situations where this can be used are more limited than
    for tuples or scalar possreps, such as that you can just use it to
    refer to the same attribute of all relation tuples at once, such as in
    some constraint definitions.  (Also noted there that, for now, other
    parts of the Muldis D spec may ignore this new fact.)

    * (Types_Catalog.pod)  Muldis D now officially has the concept of a
    relation having exactly one (or none) primary key, which is privileged
    over other unique keys it might have.  A primary key permits a tuple to
    have an identity other than the sum-total of all its attributes' values
    (being instead just the sum-total of its primary key attributes), so
    that it is now possible to conceive that a tuple in a relation may be
    "updated", rather than just be replaced with a different tuple.  This
    change should simplify some implementation details, such as
    auto-mapping of split relvars, and it should also make transition
    constraints easier to define, as often such are based on the concept of
    a relvar tuple being updated.  Mostly this change involved rewriting
    the description of the "is_primary" attribute of the "Cat.KeySet" type;
    but the "Cat.DistribKeySet" and "Cat.InnerNonscalarType" types were
    also affected.

    * (Types.pod, Types_Catalog.pod)  Updated the various system-defined
    relation types, or relation-typed attributes of other types, that were
    indicated to have (unique) keys on them, so that some (in fact, most)
    of those explicit keys are now explicitly privileged as primary keys
    instead.  For the general purpose types, just C<Array> and C<Bag> had
    this update.

    * (Types_Catalog.pod)  Added a "is_base" attribute to the
    "Cat.PossrepSet" type, which is an optimization hint for less
    intelligent Muldis D implementations as to how they choose a physical
    representation for a scalar type.

    * (Types_Catalog.pod, Rational.pod)  Updated the documentation for all
    4 of the system-defined multiple-possrep scalar root types to indicate
    that each has an implementation hint for choosing a physical
    representation; the types in question are: "Cat.(|Decl)NameChain"
    ("flat"), "Cat.Order" ("int"), "Rat" ("float").

    * (Routines_Catalog.pod)  Added new function
    "sys.std.Core.Cat.Order_reduction" which provides the canonical terse
    way to chain multiple order determination function calls into a larger
    such function, typically as the controller for when you want to sort a
    relation's tuples, as per a generic SQL "ORDER BY".

    * (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod)  Added new/first pragma to both
    Tiny dialects named "auto_complete", which when turned on lets a
    programmer omit specifying some attributes of literals, and those
    missing ones will be automatically supplied by the parser with default
    values from the relevant types.  So this now makes official a kind of
    optional brevity that was often done in example code that tended to cut
    the size of Tiny code in half from what it otherwise would have been.
    Almost all of the pod additions were in HDMD_Perl_Tiny.pod, as a new
    main section "MULDIS D TINY DIALECT PRAGMAS" at the end; like that
    file's pod in general, it speaks for both Tiny dialects.  The only
    change in PTMD_Tiny.pod was addition of a code sample of a Muldis D
    language name declaration that turned the pragma on.

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

    * Muldis::D version 0.44.0 is released on CPAN as
    Muldis-D-0.44.0.tar.gz.

    * Rounded out the Core.pod file tree by adding the new file
    lib/Muldis/D/Core/Routines_Catalog.pod, which debuts at version 0.0.0;
    this new file is where the core Muldis D data definition routines would
    be defined.  The appropriate references were added in other files
    [Core.pod, the README file].

    * New file versions are: D.pm 0.44.0 and Types_Catalog.pod 0.33.1 and
    Routines.pod 0.29.0 and Relation.pod 0.27.0 and Text.pod 0.26.0 and
    Core.pod 0.21.3.  The other pre-existing versioned files are unchanged.

    * (Routines.pod)  Fixed the "upd_invo" routine so that its "upd_args"
    parameter is non-optional, because all updaters have at least 1
    subject-to-update parameter.

    * (Text.pod)  Muldis D now just has a single function for testing the
    length of a Text value, which is "length_in_graphemes"; this replaces
    the previous 4 functions "length_in_nf(c|d)_(graphs|codes)".

    * (Routines.pod, Relation.pod)  Added a set of 18 new update operators
    where each is a short-cut over a relational function plus a generic
    assignment of the function's result to the main relvar argument of the
    function; a subset of these correspond directly to the common SQL
    "INSERT|UPDATE|DELETE" statements.  In Routines.pod, these 11 updaters
    were added as "sys.std.Core.Relation.\w+":
    "assign_(|disjoint_)(insertion|union)",
    "assign_(deletion|(|cmpl_)restriction)",
    "assign_(intersection|(|semi)difference|semijoin)".  In Relation.pod,
    these 7 updaters were added as "sys.std.Relation.\w+":
    "assign_exclusion",
    "assign_(|static_)substitution(|_in_(restriction|semijoin))".

    * (Routines_Catalog.pod)  In a reversal of one aspect of release
    0.19.0, brought back the then-removed "Cat.Order_reverse" function,
    under the slightly updated name "sys.std.Core.Cat.Order_reverse".

    * (Routines_Catalog.pod)  Added an initial complement of 22 data
    definition procedures, each of which is an abstraction for inserting or
    deleting a tuple in a catalog relvar.  These 22 procedures were added
    as "sys.std.Core.Cat.\w+":
    "(create|drop)_(depot_mount|subdepot|package)",
    "(create|drop)_(depot|package)_(function|updater|procedure|type)".  In
    addition, the 1 procedure "alter_depot_mount_so_we_may_not_update" was
    added in that namespace, which instead updates a catalog tuple.

    * (Routines.pod)  Added an initial complement of 7 generic standard I/O
    system service routines, which should now round out provisioning Muldis
    D to be computationally complete.  The 7 system service routines were
    added as "sys.std.Core.STDIO.\w+": "(read|write|error)_Text(|_line)",
    "prompt_Text_line".  These are mainly for implementing command-line
    user interfaces and error diagnostics for programs, and just handle
    Text; there are no bit string equivalents as yet.

    * (Types_Catalog.pod)  Fixed a few typos.

2008-07-29  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.43.0 is released on CPAN as
    Muldis-D-0.43.0.tar.gz.

    * New file versions are: D.pm 0.43.0.  The other pre-existing versioned
    files are unchanged.

    * Savagely chopped the Live Talk version of the Muldis_D_PDAFP_200807
    slideshow to remove all the content text, keeping just the section
    headings, a handful of bullets, and all but one of the code samples.
    There should be no doubt whatsoever now that the presenter isn't
    reading the slides; also, this result is more like the actual Takahashi
    format that the XUL software is designed for; also, it now should be
    easier to fit into the allowed time.  This was presented at OSCON on
    July 23.  Then the Stand Alone version had its end updated to format
    like the rest of the SA slideshow.  And so following this, this
    2-version 2008 July slideshow is now frozen into the archives.

    * The file archives/OSCON2008SessionProposal.txt was moved from the
    Muldis Rosetta version control / distribution to the Muldis D one; also
    there is now just one copy versus with 2 versions of Muldis Rosetta.

2008-07-21  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.42.0 is released on CPAN as
    Muldis-D-0.42.0.tar.gz.

    * New file versions are: D.pm 0.42.0.  The other pre-existing versioned
    files are unchanged.

    * Edited and trimmed the slideshow "archives/Muldis_D_PDAFP_200807.xul"
    substantially, removing about 30% of its size.  The changes were
    inspired largely by feedback from several sources on the version in
    release 0.41.0.  The cuts mainly were about removing "boring" parts
    like introductives and less interesting or common features; also many
    parts were edited to say the same thing in substantially fewer words;
    all in all, this was just fat trimming and the result shouldn't lack
    anything useful that was in the previous one.  This new version would
    barely fit in 45 minutes if read aloud, but it is in fact now intended
    as the paper for download, so people not at a live talk based on this
    can still get all the material.  There was also some reordering, and a
    bit of additions near the front to make it easier to know early what
    the talk and the project is about.

    * Forked said slideshow into a "_sa" (Stand Alone) and "_lt" (Live
    Talk) version, the former being the version for viewing on its own, or
    use as speaker's notes, and the latter for actual display during the
    talk.  The live version changes the quasi-sentences of the stand alone
    to bullet points and less text.  This was presented at PDXPug PGDay on
    July 20th.

    * Partly due to feedback gotten at the OSCON speakers' workshop on July
    21, the talk will be redone again, using a different presentation tool,
    and making the live version have very little content so it differs
    greatly from what is spoken, this all in preparation for July 23.

2008-07-15  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.41.0 is released on CPAN as
    Muldis-D-0.41.0.tar.gz.

    * New file versions are: D.pm 0.41.0 and Basics.pod 0.27.1 and
    HDMD_Perl_Tiny.pod 0.22.1.  The other pre-existing versioned files are
    unchanged.

    * (Basics.pod, HDMD_Perl_Tiny.pod)  Fixed typos.

    * Rewrote the slideshow "archives/Muldis_D_PDAFP_200807.xul" so it has
    more appropriate content, and is a better length.  While this version
    should be complete on talking about Muldis D, it still lacks anything
    on Muldis Rosetta, which should end up about 10% of the size, except
    that there are internal todo notes on this.  And next I'll need to chop
    down the size of the new version so it can be presented in about 45
    minutes, for which I'll solicit advice.  That cut version should be in
    a near future subsequent release.

2008-07-08  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.40.0 is released on CPAN as
    Muldis-D-0.40.0.tar.gz.

    * New file versions are: D.pm 0.40.0.  The other pre-existing versioned
    files are unchanged.

    * Added new file "archives/Muldis_D_PDAFP_200807.xul" which is the very
    rough first draft of the slideshow for the 2008 July talk "Muldis D -
    Portable Databases At Full Power".  This talk is created for giving at
    OSCON 2008, and it is also being given at several other events in 2008
    July.  Following a practice presentation on 2008 July 8th, which used
    the (first half of) this exact file (except new postscript first
    screen), it was decided to completely rewrite the slideshow with
    different content.  Meanwhile this version is now being released on
    CPAN for posterity.  The next CPAN release of Muldis D will not have
    this version, rather its replacement.  This talk is a XUL file and it
    requires Mozilla Firefox to run (or you can read its text in a text
    editor).  Also added the 2 support files "archives/takahashi.(css|js)"
    plus the file "archives/README".

2008-07-04  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.39.0 is released on CPAN as
    Muldis-D-0.39.0.tar.gz.

    * New file versions are: D.pm 0.39.0 and Types_Catalog.pod 0.33.0 and
    Routines.pod and Array.pod 0.28.0 and Basics.pod 0.27.0 and Ordered.pod
    and Relation.pod and Set.pod 0.26.0 and Tuple.pod and Bag.pod 0.25.0.
    The other pre-existing versioned files are unchanged.

    * (Types_Catalog.pod)  Updated the catalog type 'DKMemRelAttrMap' so
    its 'rel_name' attribute is now a 'DeclNameChain' rather than a 'Name'.
    So now, relation-typed attributes participating in a common distributed
    (unique) key no longer have to be direct siblings, but rather could be,
    eg, cousins instead; that is, now members of a distributed key may be
    spread out in different namespaces (within a common depot).

    * (Basics.pod, Types_Catalog.pod)  Added new routine kind
    "virtual_attr_map" in the ROUTINES main section, so to formalize the
    concept of a mapping function used to define virtual nonscalar
    attributes in terms of a functional dependency on other attributes, in
    general not 1:1.  Added new catalog type 'VirtualAttrMapSet' which
    embeds such a function and defines virtual attributes of a nonscalar
    type which it is embedded into; also added 'NameDNCMap' which supports
    the first addition.  Updated the 'InnerNonscalarType' catalog type to
    add a new 'virtual_attr_maps' attribute.  Features provided by this
    update include virtual relvars (views), and the easier ability to do
    things like case-insensitive key constraints.

    * (Types_Catalog.pod)  Added 3 new catalog types ['ForeignKeySet',
    'ForeignDistribKeySet', 'FKChildAttrParentAttrMap'], and added 2 new
    attributes 'foreign_(|distrib_)keys' to the 'InnerNonscalarType' type.
    These additions provide canonical abstraction syntax for
    foreign/referential key constraints between relation-valued attributes
    or their attributes etc of a nonscalar type; two versions exist, one
    that targets a key of a single relation as the parent, and one that
    targets a distributed key on multiple relations as the parent.

    * (Types_Catalog.pod)  Added 4 new quasi-scalar catalog types
    '(Func|Proc|Type|OrdDetFunc)Ref' as an initial solution to the problem
    that plain 'NameChain' don't actually work too well as values to
    represent closures or higher order functions in the general case,
    particularly when wanting to use an inner routine as a closure to pass
    to another routine defined in some external context; these were added
    in the new main pod section "TYPES FOR SPECIAL ENTITY REFERENCES".
    Also added 4 new expression node catalog types,
    '(Func|Proc|Type|OrdDetFunc)RefLitExprNodeSet', for selecting values of
    the first 4 types.  Also added 5 new attributes to the 'ExprNodeSet'
    type that are of the 4 new node types.

    * (Routines.pod, Ordered.pod, Tuple.pod, Relation.pod, Set.pod,
    Array.pod, Bag.pod)  Updated all routine parameters that conceptually
    were closure-et-al-typed (each such parameter took the name of a
    function or imperative routine or data type), so that their actual
    types were the new '(Func|Proc|Type|OrdDetFunc)Ref' types rather than
    the 'NameChain' type.  Also updated all routine parameters that take a
    set of argument values for closures so that the data type of said
    parameters is 'QuasiTuple' rather than 'Tuple', which is more
    appropriate in the general case.

2008-06-30  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.38.0 is released on CPAN as
    Muldis-D-0.38.0.tar.gz.

    * New file versions are: D.pm 0.38.0 and Types_Catalog.pod 0.32.0.  The
    other pre-existing versioned files are unchanged.

    * (Types_Catalog.pod)  Split up the catalog type 'ProcStmt' 3 ways into
    the catalog types ['StmtNodeSet', 'CompoundStmtNodeSet',
    'ProcInvoStmtNodeSet']; also updated the 'InnerProcBody' type to rename
    its 'stmts' attribute to 'stmt' and retype that attribute from
    'array_of.ProcStmt' to 'StmtNodeSet'.  So now the main body of a
    procedure has been restructured to be more like the main body of a
    function, such that the procedure body is now a tree of statement nodes
    rather than a flat sequence of statements; now each tree node is a code
    block grouping its child nodes.  This restructuring has resulted in 2
    initial kinds of statement nodes; a compound statement node is a
    sequence of other statements; a procedure invocation node invokes a
    named procedural routine.

    * (Types_Catalog.pod)  Added new catalog type 'LeaveStmtNodeSet' which
    represents an abnormal exit from a statement block or a return from a
    procedure ('abnormal' meaning not running to the end).  Also made
    corresponding attribute addition to 'StmtNodeSet' type.

    * (Types_Catalog.pod)  Renamed the 2 catalog types ['IfThenExprMap',
    'WhenThenExprMap'] to ['IfThenMap', 'WhenThenMap'] and generalized
    their descriptions so they apply to both control flow statements as
    well as control flow expressions.  Also moved those into the "SIMPLE
    GENERIC NONSCALAR TYPES" section from the "TYPES FOR DEFINING INNER
    ROUTINE BODIES" section.

    * (Types_Catalog.pod)  Added 2 new catalog types ['IfElseStmtNodeSet',
    'GivenWhenDefStmtNodeSet'] which (together with the aforementioned 2
    renamed 'Map' types) define N-way if-else and given-when-default
    control flow statement nodes.  They are like the similarly named
    expression node kinds but for being imperative.  Also made
    corresponding attribute additions to 'StmtNodeSet' type.

    * (Types_Catalog.pod)  Added new catalog type 'LoopStmtNodeSet' which
    implements a generic looping block statement; the looping block is an
    infinite loop save for exiting when an appropriate 'LeaveStmtNodeSet'
    is invoked within it.  Also added new catalog type 'IterateStmtNodeSet'
    which will jump to the start of the next iteration of a current loop.
    Also made corresponding attribute additions to 'StmtNodeSet' type.

2008-06-28  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.37.0 is released on CPAN as
    Muldis-D-0.37.0.tar.gz.

    * New file versions are: D.pm 0.37.0 and Types_Catalog.pod 0.31.0 and
    Routines.pod 0.27.0.  The other pre-existing versioned files are
    unchanged.

    * (Types_Catalog.pod)  Renamed the catalog type 'InnerDomainType' to
    'InnerUnionType' and added new catalog type 'InnerRestrType'; the
    latter is now a more terse way to specify the common kind of type that
    is a simple subset of a single other type, either a proper subtype or a
    non-proper one that has a different default value.  Also renamed the
    'InnerDomTypeSet' type to 'InnerUniTypeSet' and added the new
    'InnerRestrTypeSet' type.  Also renamed the 'InnerNonScaTypeSet' to
    lowercase the first 'S'.  Also 'InnerTypeSet' now has 4 attributes.
    Any other catalog types which had attributes of any of the above types
    were also appropriately updated.

    * (Types_Catalog.pod)  Added 4 new catalog types ['IfElseExprNodeSet',
    'IfThenExprMap', 'GivenWhenDefExprNodeSet', 'WhenThenExprMap'] which
    collectively define N-way if-else and given-when-default control flow
    expressions.  This control flow functionality is implemented using
    special catalog types rather than generically as routines because they
    carry special short-circuit semantics such that some of their operands
    are only conditionally evaluated (which isn't true with routines in
    general), generally because some operands are determining whether we
    even know it is legal to evaluate some other operands.  Also added 2
    attributes to the 'ExprNodeSet' catalog type, ['if_else_exprs',
    'given_when_def_exprs'].

    * (Routines.pod)  Renamed or grouped the headings of a few pod
    sections, added a few as well.

    * (Routines.pod)  Added new function 'sys.std.Core.Universal.assertion'
    which is like 'treated' but that rather than a type name argument it
    takes a boolean argument; it passes through the main value argument if
    the boolean is true, and throws an exception otherwise.  This function
    exists to support arbitrary condition assertions in pure functions
    potentially at runtime or compile time without the necessesity of
    defining superfluous new types with type constraints.

    * (Routines.pod)  Added 3 new control-flow routines named
    'sys.std.Core.Control.(func|upd|proc)_invo', each of which takes a
    routine name as an argument and then invokes it with arguments given as
    another argument.  These are the fundamental routines over which other
    routines that want to invoke a routine whose name or parameters they
    might not know until runtime would do it, such as generic relational
    restriction or the map or reduction operators or try_catch.

2008-06-24  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.36.0 is released on CPAN as
    Muldis-D-0.36.0.tar.gz.

    * New file versions are: D.pm 0.36.0 and Types_Catalog.pod 0.30.0 and
    Blob.pod and Array.pod and Rational.pod 0.27.0 and Basics.pod and
    Routines.pod and Integer.pod 0.26.0 and Ordered.pod and Text.pod and
    Relation.pod and Set.pod 0.25.0 and Bag.pod 0.24.0 and Conventions.pod
    0.3.0.  The other pre-existing versioned files are unchanged.

    * (Array.pod)  Fixed 'limit_of_Array_from_wrap' so 2 of its parameters
    are named 'ord_(func|assuming)' and not '(func|assuming)'.

    * (Basics.pod, Types_Catalog.pod)  Added support for routines to have
    optional parameters in addition to non-optional parameters, rather than
    just the latter kind; when no explicit argument is given to an optional
    parameter, its value will default to the default value of its declared
    type; for subject-to-update parameters, this also results in a
    temporary variable.  In Basics.pod, added a paragraph to the pod
    section "ROUTINES" that introduces this feature.  In Types_Catalog.pod,
    added a new "opt_params" attribute to each of the 3 catalog types
    "Cat.(Func|Upd|Proc)Head", which says which parameters are optional.
    Also updated Basics.pod to say that the third "assuming" parameter of a
    "order_determination" function is now optional.

    * (Conventions.pod)  Added new pod section "Defaults and Options" which
    has suggestions concerning the use of optional parameters and default
    values for types.

    * (Types_Catalog.pod, Ordered.pod, Array.pod)  Added new scalar catalog
    type 'OrdDetFuncNameChain' which is the same as 'NameChain' but for
    having the different default value of 'sys.std.Core.Scalar.order'.
    Also updated every 'func' parameter of 'sys.std.Ordered.\w+' to be
    declared of the new type rather than 'NameChain'.  Likewise updated the
    declared type of 'ord_func' of 'sys.std.Array.Array_from_attr'.

    * (Routines.pod, Ordered.pod, Integer.pod, Blob.pod, Text.pod,
    Relation.pod, Set.pod, Array.pod, Bag.pod, Rational.pod)  Made some
    routine parameters optional, which are listed here; the optional
    parameters were marked in routine signatures by adding a '?' like in
    Perl 6, an example being 'foo(Bool)?'.  In Routines.pod: every
    'possrep' of 'sys.std.Core.Scalar.\w+', 'assuming' of
    'sys.std.Core.Scalar.order', every '\w*assuming' of
    'sys.std.Core.Relation.\w+', '(try|catch)_(updating|assuming)' of
    'sys.std.Core.Control.try_catch'.  In Ordered.pod: every 'func' and
    'assuming' of 'sys.std.Ordered.\w+', 'm(in|ax)_is_outside' of
    'sys.std.Ordered.is_(in|out)side_range'.  In (Integer|Rational).pod:
    'exclude_m(in|ax)' of 'sys.std.(Integer|Rational).fetch_random'.  In
    (Blob|Text).pod: 'fixed_(start|end)' of
    'sys.std.(Blob|Text).is(|_not)_substr'.  In
    (Relation|Set|Array|Bag).pod: every '\w*assuming' of
    'sys.std.(Relation|Set|Array|Bag).\w+'.  In Array.pod:
    'ord_(func|assuming)' of 'sys.std.Array.Array_from_attr'.

    * (Text.pod)  Added new pod section "FUNCTIONS FOR TEXT NORMALIZATION"
    and moved into it the 3 functions "case_folded_to_(upper|lower)" and
    "whitespace_trimmed"; also added 2 new functions in that section named
    "accents_stripped" and "ASCII".  This function group in general is
    about normalizing text such as to support operations like case or
    accent or whitespace insensitive comparison or sorting; similarly they
    are useful upon which to build an emulation of a naturally insensitive
    language over the case et al sensitive Muldis D.

    * (Text.pod)  Added new pod section "FUNCTIONS FOR PATTERN MATCHING AND
    TRANSLITERATION" with an initial complement of 2 operators
    "is(|_not)_match_using_like" that implement the full generalization of
    SQL's "(|NOT )LIKE" operators.  Later on we need to add operators for
    transliteration, and Perl regular expression matching, and so on.

2008-06-21  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.35.0 is released on CPAN as
    Muldis-D-0.35.0.tar.gz.

    * New file versions are: D.pm 0.35.0 and Blob.pod and Array.pod and
    Rational.pod 0.26.0 and Basics.pod and Routines.pod and PTMD_Tiny.pod
    and Integer.pod 0.25.0 and Ordered.pod and Tuple.pod and Relation.pod
    and Set.pod 0.24.0 and HDMD_Perl_Tiny.pod 0.22.0 and Temporal.pod
    0.8.1.  The other pre-existing versioned files are unchanged.

    * (Basics.pod)  Added new "Type Safety" pod section under TYPE SYSTEM,
    which says such things that Muldis D is type safe, it is hybrid
    static/dynamic, some other things.  Also it declares that Muldis D now
    has a concept of "warnings" and some things that used to be fatal
    errors are now by default warnings instead; mainly this concerns
    fatalism concerning 'incompatible' declared types in contexts where the
    values in question are valid for the contexts.  Also updated some other
    sections under TYPE SYSTEM, and a few other spots in the file.  Also
    added new term 'warn' to the NOTES ON TERMINOLOGY section, which is
    related to but distinguished from 'fail'.

    * (Routines.pod, Ordered.pod, Tuple.pod, Relation.pod, Set.pod,
    Array.pod)  Updated the documentation for several routines that stated
    failure conditions so that some of those are now warning conditions
    instead.  The primary change here is that "is_identical" now will
    always warn (and probably result in false) where it used to fail, and
    there are now no conditions where it will fail; so now the system will
    let you compare any value to any value regardless of the declared types
    of their sources; but declared types will have an affect on whether
    there is a warning or not, in case you want to be told when you compare
    an integer to a string.  Also, "assign" will now only fail if the value
    to assign isn't of the declared type of the target; it will now warn
    instead of fail if the declared type of the value isn't compatible.  A
    lot of other changes related to tuple or relation values versus
    declared types, and various other fall-out from the is-identical
    change.

    * (Relation.pod, Set.pod)  Updated the 'outer_join_with_defaults' and
    'attr_or_default' functions so that each now has an extra
    Cat.NameChain-typed argument that specifies the type to use the default
    value of; the functions no longer use the declared type of some other
    of their arguments to use the default of, since that is unreliable.

    * (Routines.pod, Relation.pod, Blob.pod)  Updated the 7 functions
    ['union', 'disjoint_union', 'intersection'; 'exclusion'; 'and', 'or',
    'xor'] so that they now fail when given zero input elements rather than
    result in an identity value; while such identities conceptually exist,
    an empty input element list lacks the information to make one, so for
    these functions the best general solution is to make the caller work
    around the zero element limitation as it sees fit (such as adding an
    identity value to the input list); adding an identity parameter instead
    was rejected as that makes the most common use cases more verbose.

    * (Relation.pod)  Deleted the 2 functions ['universal', 'negation']
    since they wouldn't have worked in the current forms; they depend on
    knowing a declared type which isn't reliably obtainable without being
    explicitly given in an extra parameter; moreover most universal
    relations would be too large to handle or infinite.  Also updated the
    'empty' function description.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Fixed a bug in the grammar of
    the 'radix' format for specifying a Rat literal; the bug was such that
    one couldn't select a non-zero rational value between -1 and +1
    exclusive; that is, one couldn't say something like "0.N".

    * (PTMD_Tiny.pod)  Refactored the grammar concerning integers and
    rationals to factor out the 3 new tokens int_max_col_val, int_body,
    pint_body.  Affected older tokens were 'int', 'count', 'rat_\w+'.

    * (Ordered.pod)  Updated the 2 "is_(in|out)side_range" functions to
    rename each of their 2 "m(in|ax)_is_inside" parameters to
    "m(in|ax)_is_outside"; and now the min|max values are included in the
    range to check against rather than being excluded.

    * (Integer.pod, Rational.pod)  Added 1 system service routine to each
    file named "sys.std.(Integer|Rational).fetch_random", respectively,
    which generates a random number using some implementation-defined
    method, which may be anywhere from truly random to pseudo-random.  The
    routines take parameters to specify the domain the generated number
    must be in, which consists of range endpoints for both routines, as
    well as a maximum precision specifier for the rational one.  In the
    future, these routines may be replaced by more that give the user some
    control over what algorithm is used to produce the random numbers, or
    to specify a seed where applicable.

    * (Temporal.pod)  Made a few typo fixes in routine signatures.

2008-06-13  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.34.0 is released on CPAN as
    Muldis-D-0.34.0.tar.gz.

    * New file versions are: D.pm 0.34.0 and Temporal.pod 0.8.0.  The other
    pre-existing versioned files are unchanged.

    * In summary, this release consists just of a rewrite of the Muldis D
    Temporal Extension, which seems to improve the complement of data types
    from before, and also adds a complement of operators, which there were
    none of before.  That said, the new version still appears to have some
    serious issues which should be dealt with in the future.  One problem
    is the combinatorial explosion of types and routines, due to desire to
    have a wall between different precisions.  Another problem concerns
    interaction of plain 'time' types and time zones, such as what
    semantics their operators should have.

    * (Temporal.pod)  Rewrote the complement of temporal data types.  In
    summary, the previous 10 temporal scalar root types were replaced by 21
    new temporal scalar root types; these new types all have a possrep each
    that is formally defined, while the old types had no possreps defined.
    For specifics: 2 'DurationOfDays(No|With)TZ' became 1 'DurationOfD', 2
    'Duration(No|With)TZ' became 1 'DurationOfFS', 2 'Date(No|With)TZ'
    became 1 'DateToD', 2 'DateTime(No|With)TZ' became 2
    'DateToFS(|WithTZ)', 2 'Time(No|With)TZ' became 2 'TimeToFS(|WithTZ)',
    4 'DurationOf(Y|M|I|S)' were added, 4 'DateTo(Y|M|I|S)' were added, 2
    'DateTo(I|S)WithTZ' were added, 4 'TimeTo(I|S)(|WithTZ)' were added.
    Also added 6 proper subtypes of 'Int' named ['NZInt', 'PInt(12|31)',
    'UInt(23|59|62)'], and 1 proper subtype of 'Rat' named 'URatLT1', to
    the Temporal Extension in order for the aforementioned new scalar root
    types to be implemented over.

    * (Temporal.pod)  Rewrote the file's DESCRIPTION pod to bring it up to
    date with current changes and plans, and it is now much larger.  The
    DESCRIPTION notes that the Muldis D Temporal Extension is not meant to
    be a complete solution for temporal data, but rather is just meant to
    be good enough to support porting databases from SQL to Muldis D
    without users having to define for themselves the temporal types that
    SQL bundles.  For more complete temporal handling, users should either
    write their own custom solutions as UDTs et al or look to third-party
    Muldis D extensions.

    * (Temporal.pod)  Added initial complement of 63 temporal math
    functions and 30 system services for getting the current date.  There
    are 18 functions named
    "sys.std.Temporal.DurationOf(Y|M|D|I|S|FS).(abs|sum|difference)", and
    18 functions named
    "sys.std.Temporal.DateTo(Y|M|D|I|S|FS).(difference|later|earlier)", and
    9 functions named
    "sys.std.Temporal.DateTo(I|S|FS)WithTZ.(difference|later|earlier)", and
    18 functions named
    "sys.std.Temporal.TimeTo(I|S|FS)(|WithTZ).(difference|later|earlier)".
    There are 12 system services named
    "sys.std.Temporal.DateTo(Y|M|D|I|S|FS).fetch_current_date_(utc|local)",
    and 6 system services named
    "sys.std.Temporal.DateTo(I|S|FS)WithTZ.fetch_current_date_(utc|local)",
    and 12 system services named
    "sys.std.Temporal.TimeTo(I|S|FS)(|WithTZ).fetch_current_time_(utc|local
    )".

2008-06-04  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.33.0 is released on CPAN as
    Muldis-D-0.33.0.tar.gz.

    * New file versions are: D.pm 0.33.0 and Types_Catalog.pod 0.29.0 and
    Routines.pod 0.24.2 and Basics.pod 0.24.0.  The other pre-existing
    versioned files are unchanged.

    * (Basics.pod)  Added a short paragraph under TYPE SYSTEM that
    clarifies Muldis D does subtyping using "specialization by constraint"
    (not "by extension"), using those very terms.

    * (Basics.pod)  Rewrote a portion of the "Scalar Types" subsection of
    TYPE SYSTEM to bring it up to date concerning the nature of possreps,
    possrep maps, and particularly of the nature of what operators are or
    aren't built-in to types, and what are automatically system-defined.
    Also made a few other small changes in Basics or TYPE SYSTEM.

    * (Basics.pod, Types_Catalog.pod)  Specified that all possrep names of
    all scalar types in a common hierarchy (under the same root type) must
    have distinct names regardless of whether they share values, so to keep
    diamond inheritence more simple and deterministic.

    * (Types_Catalog.pod)  Added initial complement of catalog types that
    define controls for mounting and unmounting depots, in the new main pod
    section "TYPES FOR DEFINING MOUNT CONTROLS"; this consists of the 2 new
    types "Cat.MountControl(Cat|Set)".  This fills in one of the arguably
    very few remaining gaps in essential language functionality.  Some
    standard customizations per depot mount include readonly vs updateable,
    temporary or not, create on mount or not; most customizations are left
    to implementation-specific 'details' though, such as file names or
    authentication credentials.

    * (Basics.pod, Types_Catalog.pod, Routines.pod)  Added new routine kind
    "type_default" in the ROUTINES main section, so to formalize the
    concept of a zero-parameter function that always results in a certain
    value of a type.  Updated documentation for the 'Universal.default'
    function, and for catalog type attributes of that kind of function, to
    use that name.

    * (Basics.pod, Types_Catalog.pod)  Added new routine kind "possrep_map"
    in the ROUTINES main section, so to formalize the concept of a 1:1
    mapping function used in scalar type definitions; updated the relevant
    type-defining catalog type docs accordingly.

    * (Types_Catalog.pod)  Updated the 'Cat.PossrepSet' type so that its
    'constraint' attribute may be less restricting than otherwise when
    there are multiple possreps in the same scalar (|sub)type; the total
    constraint on a type is the 'and'-ing of all of its possrep
    constraints, so each individual one in general only needs to restrict
    enough that inter-possrep map funcs can work, and the other constraints
    can be applied too.  (This detail is subject to revision.)  Also
    updated all of the inner types to specify that their '*constraint'
    attributes default to be unconditionally true, unlike the inner-func
    default of unconditionally false.

    * (Types_Catalog.pod)  Updated the 'Cat.InnerDomainType' type so that
    it must have at least 1 source type rather than at least none, and
    updated the handling of filter types so they default to union rather
    than intersect; also renamed the is_filter_union attribute to
    is_filter_intersection; also clarified that it is invalid to declare a
    domain type that is an alias of 'Empty' due to needing a default value.

    * (Basics.pod)  In a reversal of one aspect of release 0.9.0, updated
    ROUTINES to bring back the distinct 'state_constraint' routine kind,
    and rewrote it so it is now the same as a 'type_constraint', being a
    pure function with 1 parameter rather than a routine that can see
    globals.  Also updated the definitions of 'type_constraint' and
    'transition_constraint' to conform to recent catalog formalizations;
    the first one now always just takes the single 'topic' parameter.  And
    all constraints must not unconditionally result in Bool:false.  Note
    that the catalog still doesn't define how to apply state or transition
    constraints to variables; such an update is pending.

    * (Types_Catalog.pod)  Added new type 'Cat.ConstraintSet' which defines
    a set of named generalized constraints (type or state or transition
    etc; technically its a named set of InnerFuncBody).  Updated the 2
    types 'Cat.Inner(Nonscalar|Domain)Type' to pluralize the names of their
    generic constraint attributes, and those attributes' types are now the
    ConstraintSet type rather than the InnerFuncBody type.  The net result
    of these changes is that type constraints, on particularly
    tuple|relation|database types, can now be split into N named pieces,
    which should make them easier to write when complicated, and make
    debugging or input validation easier since the name of each smaller
    constraint would be in the exception resulting from its failure.

    * (Types_Catalog.pod)  Added support for an abstraction for defining
    distributed (unique) keys over relation-valued attributes of a
    tuple/database type.  Added 3 new types Cat.DistribKeySet,
    Cat.DKMemRelAttrMap, Cat.DKRelAttrKeyAttrMap which define distributed
    keys, and added 1 new DistribKeySet-typed attribute named
    'distrib_keys' to the 'Cat.InnerNonscalarType' type.

2008-06-04  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.32.0 is released on CPAN as
    Muldis-D-0.32.0.tar.gz.

    * Renamed Sequence.pod to Array.pod; the entities it declares have all
    been renamed to "sys.std.Array.\w+" from "sys.std.Sequence.\w+".  Any
    references to these in other files [D.pm, Core.pod, Relation.pod, the
    README file] were updated accordingly.

    * New file versions are: D.pm 0.32.0 and Types_Catalog.pod 0.28.0 and
    Types.pod and Blob.pod and Array.pod 0.25.0 and Routines.pod 0.24.1 and
    PTMD_Tiny.pod and Text.pod 0.24.0 and Relation.pod 0.23.1 and
    Basics.pod 0.23.0 and Core.pod 0.21.2 and HDMD_Perl_Tiny.pod 0.21.0.
    The other pre-existing versioned files are unchanged.

    * (Basics.pod, Routines.pod)  Made a few typo fixes.

    * (Basics.pod)  In the NOTES ON TERMINOLOGY main pod section, updated
    the 'sequence' entry to add 'array' as a synonym for it.  Rather than
    avoiding the use of 'array' altogether given its more broad meaning in
    wider contexts like any indexed list, including associative arrays, we
    now simply say that those other meanings aren't used in this
    documentation, and only the meaning of an ordered collection applies.
    Also added a related item 'sequence generator' to the above entry, and
    specified that only the longer term refers to a sequence generator, and
    that 'sequence' by itself does not.

    * (Types.pod)  Renamed the 2 core types '(|Quasi)Seq' to
    '(|Quasi)Array'.  The change to use Array rather than Seq was done for
    3 main reasons, the first of which was to make the type name more
    visually distinctive from the Set type; the second reason was because
    the overwhelming majority of other languages used the name Array, and
    its not like I was using the term for anything else, and its not like
    my reason for avoiding it before was particularly good; the third
    reason was to reduce confusion about the type name referring to a
    sequence generator, as SQL users may think.  As a fourth reason, this
    change had the side-effect that the associated language extension and
    its entities now have shorter names; Array from Sequence; and the
    extension name Sequence is now freed up for possible use related to a
    sequence generator.

    * (Types_Catalog.pod)  Updated the 2 types '(|Decl)NameChain' so that
    their 'seq' possrep is now named 'array'.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Updated the literal syntax for
    '(|Quasi)Array' values to use the type's new name, and updated the
    literal syntax for '(|Decl)NameChain' values so that their new possrep
    name is used.

    * (Basics.pod)  In the "Referencing Data Types" pod section under
    ENTITY NAMES, updated the spelling for '(|quasi_)seq_of' to be
    '(|quasi_)array_of', in accordance with the type name changes.

    * (Array.pod, Types_Catalog.pod, Blob.pod, Text.pod)  Updated any
    routine signatures or nonscalar type definitions that used
    'Seq'|'seq_of' to use 'Array'|'array_of' instead.  In Array.pod, also
    renamed the 2 'is_(|not_)subseq' functions to 'is_(|not_)subarray'.

    * (Routines.pod, Relation.pod)  Updated any references on 'Seq' in the
    documentation to 'Array'; these are only description pod updates.

    * (Array.pod)  Removed 'last_index' as it seems to be less useful than
    previously thought; it isn't really a short-hand for 'cardinality'
    since to make it work also with empty sequences, it would need to
    result in a Maybe or be wrapped in tests.

2008-05-20  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.31.0 is released on CPAN as
    Muldis-D-0.31.0.tar.gz.

    * Split apart Nonscalar.pod 2 ways into Tuple.pod and Relation.pod; the
    first file got the 4 "sys.std.Nonscalar.Tuple.\w+" named functions
    (grouped in 1 pod section), and the second file got all the remaining,
    27 "sys.std.Nonscalar.Relation.\w+" named functions (grouped in 4 pod
    sections); following the split, the functions were renamed to
    "sys.std.Tuple.\w+" and "sys.std.Relation.\w+", respectively.  Any
    references to these in other files [D.pm, Core.pod, the README file]
    were updated accordingly.

    * New file versions are: D.pm 0.31.0 and Types_Catalog.pod 0.27.0 and
    Rational.pod 0.25.0 and Types.pod and Routines.pod and Sequence.pod
    0.24.0 and PTMD_Tiny.pod and Ordered.pod and Tuple.pod and Relation.pod
    0.23.0 and Basics.pod 0.22.0 and Core.pod 0.21.1 and HDMD_Perl_Tiny.pod
    0.20.0.  The other pre-existing versioned files are unchanged.

    * (Basics.pod, Types.pod)  Fixed a few fossils.

    * (Types_Catalog.pod)  Renamed the main pod sections "TYPES FOR
    DEFINING ENTITY NAMES AND COMMENTS" and "SIMPLE GENERIC CATALOG
    COLLECTION TYPES" to "SIMPLE GENERIC (|NON)SCALAR TYPES", respectively.

    * (Routines.pod)  Added new "SYSTEM-DEFINED GENERIC SCALAR-CONCERNING
    FUNCTIONS" main pod section, along with a complete complement of
    generic scalar possrep attribute extraction and updating functions.
    These 7 "sys.std.Core.Scalar.\w+" functions were added, which take
    advantage of the fact that a scalar possrep looks just like a tuple:
    '(|update_)attr', 'multi_update', '(|cmpl_)projection',
    'Tuple_from_Scalar', 'Scalar_from_Tuple'.

    * (Rational.pod)  Removed the now-redundant (with 'Scalar.\w+') 7
    rational numeric specific value selection and possrep attribute
    extraction functions: 'Rat_from_Int_(pair|triple)', 'numerator',
    'denominator', 'mantissa', 'radix', 'exponent'.

    * (Basics.pod)  Added new "Ordered Types" pod section under the TYPE
    SYSTEM main section.  It outlines the system-defined support for
    order-sensitive operators and related best practices.  Values of any
    type can be explicitly sorted, but only scalar root types can have a
    default sorting function defined for them.  Currently, only functions
    for total ordering have privileged support, but partial ordering
    functions can be user-defined over such.

    * (Basics.pod)  Added new routine kind "order_determination" in the
    ROUTINES main section, so that the concept of a "system-compatible
    fundamental order-determination function" can now be referred to by a
    terse name in the rest of the documentation.

    * (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  In a reversal
    of one aspect of release 0.19.0, brought back the then-removed
    Cat.Order enumerated scalar type, but enhanced to have 2 possreps
    rather than none (one over 'Name', one over 'Int'); also brought back
    the literal syntax specific to this type in both Tiny dialects, but
    sans any 'Cat.' prefix; also both dialects now provide for direct
    analogies to both possreps.

    * (Types_Catalog.pod, Routines.pod)  Updated the 'Cat.InnerScalarType'
    type to add a 7th attribute named 'order' which defines an optional
    type-default total ordering function, which can only be defined with a
    root type.  Added generic scalar function 'sys.std.Core.Scalar.order'
    which externalizes this function, and it is what other order-sensitive
    operators can wrap when dealing with values of such scalar types.

    * (Types.pod, Types_Catalog.pod, Rational.pod)  Updated the
    descriptions of the 10 types [Bool, Int, Blob, Text, Cat.Name,
    Cat.NameChain, Cat.DeclNameChain, Cat.Comment, Cat.Order, Rat] to
    explicitly declare that each one has a type-default ordering algorithm,
    and to describe what that algorithm is.  Also stated that the
    RatRoundMeth type does *not* have a default ordering.  (Still TODO is
    to address the temporal and spatial types in one of these manners.)

    * (Ordered.pod)  Updated all of this language extension's
    "order_determination"-wrapping functions to have the 2 extra parameters
    "func" and "assuming", so that they can be customized as to what
    fundamental function they wrap, whether one defined with the comparand
    types or otherwise.  Also added the function
    'sys.std.Ordered.reverse_order'.  Also, 'min' and 'max' no longer
    result in an identity value with zero topic elements.

    * (Relation.pod)  Added new main pod section "SYSTEM-DEFINED RELATIONAL
    RANKING AND QUOTA FUNCTIONS" with an initial complement of the 2
    "sys.std.Relation.(rank|limit)" generic relational operators.  The
    "rank" function will extend the topic relation with an integer column
    with the tuples ranked 0..N, that order determined by an
    "order_determination"-function argument that it wraps; its
    functionality is essentially SQL's "RANK" but the ordering is only
    total, so no dense / not dense distinction.  This "rank" function
    provides the basis of both arbitrary quota queries as well as making
    lists sorted.  The "limit" function provides a specific kind of quota
    query, in doing a restriction on the topic relation to a consecutive
    range of tuples ranked as per "rank"; its functionality is like SQL's
    "ORDER BY" plus "LIMIT" but the result is not a sequence.

    * (Sequence.pod)  Added the 2
    "sys.std.Sequence.(|limit_of_)Seq_from_wrap" functions, which are
    essentially the same as the above rank|limit but that the result is a
    sequence rather than a generic relation.  Prefer the sequence versions
    when immediately returning the sorted query results, versus prefer the
    rank|limit versions when using their results as a subquery in a larger
    relational query.  Also added "Seq_from_attr", which together with
    "Seq_from_wrap" are analogies to similar Set and Bag functions.  Also
    added the 2 functions "last_index" and "slice".

    * (Routines.pod)  Removed the empty main pod section "SYSTEM-DEFINED
    CORE CATALOG FUNCTIONS"; catalog-specific routines will instead go in a
    new Core/Routines_Catalog.pod file when they come to be.

2008-05-12  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.30.0 is released on CPAN as
    Muldis-D-0.30.0.tar.gz.

    * New file versions are: D.pm 0.30.0 and Types_Catalog.pod 0.26.0 and
    Integer.pod and Blob.pod and Rational.pod 0.24.0 and Types.pod 0.23.1
    and PTMD_Tiny.pod 0.22.0 and HDMD_Perl_Tiny.pod 0.19.0 and
    Conventions.pod 0.2.0.  The other pre-existing versioned files are
    unchanged.

    * (Types.pod, Types_Catalog.pod)  Fixed a few fossils.

    * (Types_Catalog.pod)  Refactored the catalog types for defining outer
    data types.  The oft-repeated attribute triple
    "inner_(sca|non_sca|dom)_types" was factored out into the new tuple
    (database) type Cat.InnerTypeSet, and a single "inner_types" attribute
    of that type is now used in the outer routine and type defining types
    rather than the triple.  The 3 "Cat.(Scalar|Nonscalar|Domain)Type"
    types were combined into the 1 "Cat.Type" type; now an outer type must
    have at least 1 inner type, which defines the outer type, and that
    inner type has the empty string for its name; this arrangement is akin
    to an expression node hierarchy.  Along with that, the 9
    "Cat.(Sys|Dep|Pkg)(Sca|NonSca|Dom)TypeSet" types were combined into the
    3 "Cat.(Sys|Dep|Pkg)TypeSet" types, and the corresponding 3 attributes
    in each of "Cat.(System|Depot|Package)" were consolidated into 1
    attribute for each.

    * (Rational.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Renamed the
    rational extension enumerated type "E_RM"/"Cat.E_RM" to just
    "RatRoundMeth", and also updated its literal syntax in both Tiny
    dialects likewise.

    * (Rational.pod)  Updated the "RatRoundMeth" type so that it explicitly
    has a possrep that wraps the Cat.Name type, rather than implicitly
    having no possreps.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Abbreviated the literal syntax
    for scalar catalog types in both Tiny dialects so that the literals no
    longer have a leading "Cat."; this affects the 4 types: Name,
    NameChain, DeclNameChain, Comment; but with Name it only affects the
    documentation since its literals had no 'Name' prefix to begin with.

    * (Integer.pod, Blob.pod, Rational.pod)  Updated the documentation so
    that any types declared by these files which were referred to with a
    "Cat." prefix now aren't; the affected types were "RatRoundRule" and
    several "PInt\d\w+".

    * (Conventions.pod)  Removed the suggestion about enumerated types
    being named like E_FOO; for one thing, no system-defined enums do that
    anymore; also that format may be too terse for general practice.

2008-05-11  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.29.0 is released on CPAN as
    Muldis-D-0.29.0.tar.gz.

    * New file versions are: D.pm 0.29.0 and Types_Catalog.pod 0.25.0 and
    Types.pod and Routines.pod and Integer.pod and Blob.pod and Text.pod
    and Set.pod and Sequence.pod and Bag.pod and Rational.pod 0.23.0 and
    Nonscalar.pod 0.22.0 and Basics.pod and PTMD_Tiny.pod 0.21.0 and
    HDMD_Perl_Tiny.pod 0.18.0.  The other pre-existing versioned files are
    unchanged.

    * (Basics.pod)  Added new "User Namespace Correspondence" pod section
    under ENTITY NAMES.  It says how the namespaces *.lib and *.data
    inter-relate, for example when they need to have corresponding sections
    and when they need to have non-conflicting ones.  Also, when a depot
    has no subdepots or packages, then its "dep.data" is "just a database".

    * (Basics.pod)  Added new "Referencing Data Types" pod section under
    ENTITY NAMES.  It specifies a couple new language features, the first
    of which lets you directly reference types that were baked into the
    external interfaces of other entities like variables or routines, as if
    they were normal explicitly declared types; also you can simply take
    the corresponding tuple type for a relation type or vice-versa; the
    second feature is that you can tersely declare simple collection types
    inline, such as sets or sequences of Foo, saving the language and users
    from a proliferation of explicitly declared simple (|quasi-)nonscalar
    types like C<MaybeOfInt> or C<SeqOfText>.

    * (Types.pod)  Removed the 6 explicitly declared tuple type factories
    "(|Quasi)(Set|Seq|Bag)Elem", which are now superfluous as you should
    now be able to use the "tuple_from" syntax on the
    "(|Quasi)(Set|Seq|Bag)" type factories instead, if you need them.

    * (Types.pod, Types_Catalog.pod, Integer.pod, Blob.pod, Text.pod,
    Rational.pod)  Removed the 38 explicitly declared 'Of' types which are
    now superfluous: 24
    "(Set|Maybe|Seq|Bag)Of(Bool|Int|UInt|Blob|Text|Rat)", 4
    "(Set|Bag)Of(Tuple|Relation)", SetOfBag, MaybeOfTuple, SeqOfSeq, 2
    "QuasiSetOf(Tuple|Relation)", SeqOfProcStmt, 4
    "SetOf(Name|NameExprMap|SetOfName|NameChain)".

    * (Types_Catalog.pod, Routines.pod, Integer.pod, Blob.pod, Text.pod,
    Nonscalar.pod, Set.pod, Sequence.pod, Bag.pod, Rational.pod)  Updated
    all references to the aforementioned deleted 'Of' types, in type
    attributes and routine signatures, to refer to the implicitly generated
    '_of' versions instead.  In Types_Catalog.pod, this also means that the
    whole SYSTEM-DEFINED CORE QUASI-CATALOG PARAMETERIZED TYPES pod section
    was eliminated.

    * (Types.pod)  Updated descriptions of the Database and Single types.

    * (Types_Catalog.pod)  Updated the 4
    "Cat.(System|Federation|Depot|Package)" types to ensure that they
    actually are "Database" types and not "just Tuple" types, since each
    "cat" variable is supposed to be a valid "database".  The only change
    for each of the 4 types was to convert type of its "comment" attribute
    from "Cat.Comment" (a scalar) to "single_of.Cat.Comment" (a relation);
    the latter type was also added under the misc collection types section.
    Also clarified that the "Cat.ExprNodeSet" type qualifies as a db type.

    * (Types_Catalog.pod)  Updated the 4 "Cat.Sys(Nsp|Func|Upd|Proc)Set"
    types to flesh out the definition of their 'parent' attributes (which
    had been left 'TODO'), and expanded the description of the "namespaces"
    attribute of the "Cat.System" type.

    * (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Refactored
    the catalog types for defining data types.  Previously, there was just
    the single C<Cat.Type> main type, plus 2 supporting enumerated types,
    that handled all of special types, root scalar and nonscalar types,
    domain types and union etc types.  Now C<Cat.Type> has been replaced
    with mainly these 9 types: Cat.(|Inner)(Scalar|Nonscalar|Domain)Type,
    Cat.Possrep(|Map)Set, Cat.KeySet; they handle all of the aforementioned
    but for special types.  There are 3 main type definition methods for
    user-defined types, each of which is represented by an outer/inner
    pair; the inners do all the work and outers are just wrappers for those
    to make them explicit depot etc entities; multiple inners can be in an
    outer, all but one playing support to the one, and inner types also can
    be embedded in outer routines.  With Cat.Type gone, the 2 enumerated
    types Cat.E_TK and Cat.E_TDM were no longer useful and were eliminated;
    along with their types, the special literal syntax for Cat.E_TK and
    Cat.E_TDM was eliminated from the 2 Tiny dialects.  Added the 9
    Cat.(Sys|Dep|Pkg)(Sca|NonSca|Dom)TypeSet types and updated the
    Cat.(System|Depot|Package) types to each have 3 corresponding
    attributes, rather than each having a placeholder 'types' attribute.
    Added the 3 Cat.Inner(Sca|NonSca|Dom)TypeSet types and updated the
    Cat.(Func|Upd|Proc)Body types to each have 3 corresponding attributes,
    rather than each having a placeholder 'inner_types' attribute; the 3
    new outer type types each have the 3 corresponding attributes also.
    Also added the 2 Cat.Sys(Spec|ScaNPR)TypeSet types and updated the
    Sys.System type to have 2 corresponding attributes; these list the
    special system-defined types of the kinds that users can't make.

    * (Types_Catalog.pod)  Added 2 catalog types for defining dbvars, both
    of the catalog and user data variety: Cat.DbVar, Cat.SysCatSet. Updated
    the catalog types Cat.(System|Depot|Package) to have a 'catalog' or
    'data' attribute each rather than a placeholder.  With this, all the
    explicit TODO placeholders in Types_Catalog.pod are now gone.

    * (Types_Catalog.pod)  The placeholder catalog type Cat.Exception was
    not addressed yet, and for now has been removed; it will come back
    later; so the whole OLD TYPE DEFINITIONS TO REWRITE OR REPLACE pod
    section was eliminated.

    * (PTMD_Tiny.pod)  The statement terminator semicolon no longer exists;
    it was never needed to help parsing and its presence would probably
    have confused people.  Also added whitespace allowance between main
    parts of rational literals.

    * (PTMD_Tiny.pod)  Added DESCRIPTION paragraph to point out that the
    PTMD_Tiny dialect is designed for a single-pass parser or lexer, and so
    it should be possible to parse such code simply and with little RAM;
    also a paragraph about the flexibility programmers have for writing
    code in the dialect, such as matters of whitespace.

2008-05-09  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.28.1 is released on CPAN as
    Muldis-D-0.28.1.tar.gz.

    * New file versions are: D.pm 0.28.1 and Types_Catalog.pod 0.24.2 and
    Types.pod and Routines.pod and Ordered.pod and Integer.pod and Blob.pod
    and Text.pod and Set.pod and Sequence.pod and Bag.pod and Rational.pod
    0.22.1 and Nonscalar.pod 0.21.1 and Basics.pod 0.20.2 and PTMD_Tiny.pod
    0.20.1 and HDMD_Perl_Tiny.pod 0.17.1 and Temporal.pod and Spatial.pod
    0.7.1.  The other pre-existing versioned files are unchanged.

    * Completed the system entity renaming that began in release 0.27.0,
    such that all fully-qualified references to types and routines in the
    'sys.[A-Z]\w+' namespace have been renamed into the 'sys.std.[A-Z]\w+'
    namespace.  This was the only change made for release 0.28.1.  To be
    specific, the usage of 'sys.std' was already official in 0.27.0, and it
    was just that most documentation was out of date until now.

2008-05-01  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.28.0 is released on CPAN as
    Muldis-D-0.28.0.tar.gz.

    * New file versions are: D.pm 0.28.0 and Types_Catalog.pod 0.24.1 and
    Basics.pod 0.20.1 and PTMD_Tiny.pod 0.20.0 and HDMD_Perl_Tiny.pod
    0.17.0.  The other pre-existing versioned files are unchanged.

    * (PTMD_Tiny.pod)  Seq literals now use square brackets as list
    delimiters rather than curly braces like most literals.  It was decided
    to standardize on using square brackets to delimit the few lists where
    the order of elements in the literal is significant, while leaving the
    curly braces for the majority lists where the order is not significant.

    * (PTMD_Tiny.pod)  All the separator and list delimiter tokens (that
    are outside character string literals) now allow whitespace around
    them, which can help you wrap long lines.

    * (PTMD_Tiny.pod)  Character string literals may now be divided into
    1..N consecutive character string literal segments which are separated
    by the (whitespace delimited) segment stitching character '~' (tilde);
    this can help you wrap long character strings into multiple lines.
    Likewise, blob literals can now be segmented using the same token.  Now
    we could have tried likewise with numeric literals too, but decided not
    for simplicity, as the odds of that being used are next to none.  Also
    the flat formats for name chains can not be segmented; if you have one
    that long, then use the sequence format for name chains instead.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Added another format for generic
    relation literals that is more compact than the other main form due to
    only stating attribute names once rather than repeating them per tuple;
    the trade-off is that attribute values per tuple and their names are
    now mapped by ordinal position in the literal so attribute order is not
    immaterial; mutual order of whole tuples still is immaterial though.

    * (Basics.pod, Types_Catalog.pod, PTMD_Tiny.pod)  Fixed a few fossils.

2008-04-27  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.27.0 is released on CPAN as
    Muldis-D-0.27.0.tar.gz.

    * Removed the very incomplete file Hierarchical.pod, as it has become
    more superfluous given the other Tiny dialects becoming more terse and
    better for regular use.  Not that other dialects can't be introduced
    later, but they aren't as necessary now.

    * New file versions are: D.pm 0.27.0 and Types_Catalog.pod 0.24.0 and
    Basics.pod 0.20.0 and PTMD_Tiny.pod 0.19.0 and HDMD_Perl_Tiny.pod
    0.16.0.  The other pre-existing versioned files are unchanged.

    * (D.pm, Basics.pod)  In the ENTITY NAMES section of Basics.pod,
    refactored the builtins namespaces to unify them under 'sys'; so what
    used to be ['cat','sys','imp'] are now ['sys.cat','sys.std','sys.imp']
    respectively.  The VERSIONING section of D.pm had a corresponding
    update.  However, all the standard Muldis D routine and type
    definitions or references in the Core/* and Ext/* and Dialect/* etc
    files were *not* updated yet to the new naming scheme; those
    documentation files will be updated piecemeal instead when they already
    need to be updated for some other reason, especially for a related
    global change; meanwhile, though most pod doesn't show it, the new
    'sys.std' names are the actual official ones.  Also, 'mnt' was split
    into itself and 'mnt.cat', the latter being where the system catalog
    for controlling depot mounts actually now is.

    * (Basics.pod)  In the ENTITY NAMES section, public-invokable types
    and routines no longer have to be confined in packages, but can exist
    directly in a depot or subdepot instead.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Added generic literal syntax for
    selecting a value of any scalar or quasi-scalar type which has at least
    1 possrep.  The syntax is similar to a tuple literal, but rather than
    being "Tuple:{ <attr names and values> }" it is "Scalar:<type
    name>:<possrep name>:{ <possrep attr names and values> }".  This
    feature fills in a useability hole where previously it wasn't possible
    to have literals of most scalar types in a bootloader, and such values
    required the writing of a whole (temporary) routine to generate them.

    * (PTMD_Tiny.pod)  Updated the literal syntax for a Cat.NameChain so
    its 'seq' representation now has square brackets around the name parts.

    * (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Refactored
    the catalog types for defining value expressions and routine
    statements.  Routine parameters and variables are now invokable
    directly in expressions and statements, and are no longer invokable by
    way of 'param' or 'var' etc expression nodes.  Expression nodes and
    parameters and variables are now invoked using Cat.NameChain rather
    than Cat.Name (the implementing change was in Cat.NameExprMap), which
    allows you both to access their attributes with minimal syntax, but
    also normalizes the syntax for local and global variable access.  The 2
    types Cat.ProcStmtArg(|Set) were eliminated since, following the above
    changes, Cat.NameExprMap could be used instead for defining procedure
    statement arguments; then the Cat.E_PSAK enumerated type had no more
    uses, and was eliminated.  The 2 types Cat.(|Multi)UpdStmt were merged
    into the 1 type Cat.MultiUpdStmt, which otherwise is essentially the
    same as the old version.  The 3 types Cat.Expr(Node|Set|Tree) were
    refactored into the 6 types
    Cat.(|(Sca|ScaPR|Tup|Rel)Lit|FuncInvo)ExprNodeSet; the first of those
    is a tuple with 5 attributes, one each of the other 5 of those, which
    are relations; so then an inner routine that used to have a
    Cat.Expr(Set|Tree) attribute now has a Cat.ExprNodeSet attribute
    instead; then the Cat.E_ENK enumerated type had no more uses, and was
    eliminated.  With the previous changes, code for expressions or
    statements no longer has any inapplicable attributes, save relations
    allowed to be empty.  Along with their types, the special literal
    syntax for Cat.E_ENK and Cat.E_PSAK was eliminated from the 2 Tiny
    dialects.

    * (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Added new
    scalar type Cat.DeclNameChain, as well as its own literal syntax in
    both Tiny dialects.  This type is the same as Cat.NameChain except that
    it allows 0..N name parts rather than 2..N, and its flat possrep also
    has periods before and after the parts rather than just between them.
    This type was added for use when declaring subdepots, depot entities.

    * (Types_Catalog.pod)  Added a set of 4 top-level catalog types which
    are the types of the Muldis D catalog dbvars: Cat.System (for
    'sys.cat'), Cat.Federation (for 'fed.cat'), Cat.Depot (for 'dep.cat'
    and 'sdp.cat'), Cat.Package (for 'pkg.cat').  Added a set of 2 catalog
    types which define nodes in N-depth namespace hierarchies for
    organizing entities within a catalog: Cat.SysNspSet (hierarchies for
    system-defined entities), Cat.SubdepotSet (hierarchies for user-defined
    entities, for example SQL 'schema'); these 2 only declare that
    namespaces exist, not what entities are in them.  Added a set of 11
    catalog types which specify/embed the definitions of entities in
    catalog dbvars: Cat.DepotMountSet (what depot mounts are in a mount
    federation), Cat.PackageSet (what packages are in a depot),
    Cat.Sys(Func|Upd|Proc)Set (what system-defined routines there are),
    Cat.(Dep|Pkg)(Func|Upd|Proc)Set (what user-defined routines there are,
    directly in a depot or in a package of a depot, respectively); for the
    system-defined routines, only the routine headings/interfaces are
    specified, and for user-defined ones, both those and the
    bodies/implementations are specified.

    * (Types_Catalog.pod)  Refactored the catalog types for defining
    main|outer and inner routines, so that routine headings and bodies are
    now separate from each other, and routine declared names are now
    external to both parts; that is, a routine's name, if it has one, is
    supplied by whatever other type embeds the otherwise anonymous routine
    definition.  The 11 types Cat.(|Inner)(Func|Updater|Proc) and
    Cat.Inner(Func|Updater)(Set|Tree) and Cat.InnerProcTree were refactored
    into the 12 types Cat.(Func|Upd|Proc)(Head|Body) and
    Cat.Inner(Func|Upd|Proc)(Body|Set).  Following this refactoring plus
    the previous change item, the 'name' attribute for named functions is
    directly in each of the 12 Cat.(Sys|Dep|Pkg|Inner)(Func|Upd|Proc)Set
    types; all 12 have a 'head' attribute and all but the Sys have a 'body'
    attribute, those embedding appropriate Head and Body types, the 3
    together completely defining the routine.  Both outer and inner
    routines of the same kind use the same Head types, but have their own
    Body types.  Another change this refactoring brought is that an outer
    routine no longer requires an inner routine to define its own
    interface; now an outer routine body embeds its implementation detail
    (still an inner routine Body) directly, rather than it being a list
    item in an inner routines list whose name is the empty string;
    therefore, outer routines no longer need to have inner routines at all
    unless they do certain things.

    * (Types_Catalog.pod)  Despite the widescale refactoring, these 10
    catalog types transitioned from the previous to the current design
    while retaining their names and purpose, and also all or most of their
    own design details: Cat.Name, Cat.NameChain, Cat.Comment,
    Cat.SeqOfProcStmt, Cat.ProcStmt, Cat.NameTypeMap, NameExprMap,
    AttrRenameMap, SetOfName, Cat.SetOfNameExprMap.  Also some minor typo
    fixes with a few of the 9 QuasiCat type docs, but the whole block was
    left alone and still fits in fine.

    * (Types_Catalog.pod)  The following 6 catalog types were not addressed
    yet and still need to be rewritten/refactored: Cat.E_TK, Cat.E_TDM,
    Cat.Type, Cat.Exception, Cat.SetOfSetOfName, Cat.SetOfNameChain.  More
    generally speaking, the catalog types for defining data types (and
    databases) still need to be rewritten, or actually they mostly need to
    be written in the first place.  Hopefully by the next Muldis D release.

    * (Types_Catalog.pod)  In the process of the other changes, the 3
    largest main documentation sections, "SYSTEM-DEFINED CORE CATALOG (
    SCALAR | TUPLE | RELATION ) DATA TYPES", were reorganized into the 10
    main documentation sections "TYPES FOR DEFINING ( ENTITY NAMES AND
    COMMENTS | SYSTEM-DEFINED ENTITIES | FEDERATIONS | DEPOTS AND SUBDEPOTS
    | PACKAGES | ROUTINE HEADINGS | ROUTINE BODIES | INNER ROUTINE BODIES
    )" and "SIMPLE GENERIC CATALOG COLLECTION TYPES" and "OLD TYPE
    DEFINITIONS TO REWRITE OR REPLACE".

2008-04-21  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.26.0 is released on CPAN as
    Muldis-D-0.26.0.tar.gz.

    * New file versions are: D.pm 0.26.0 and Types_Catalog.pod 0.23.0 and
    Routines.pod 0.22.0 and Basics.pod 0.19.0 and PTMD_Tiny.pod 0.18.0 and
    HDMD_Perl_Tiny.pod 0.15.0.  The other pre-existing versioned files are
    unchanged.

    * (Basics.pod, PTMD_Tiny.pod)  Renamed the routine kind 'main' to
    'bootloader' and updated its description.  This routine kind is now not
    so much a "main program" as it is more like a thin wrapper that loads
    and invokes the main from a depot.  A bootloader can be used by both
    plain text and hosted data Muldis D, not just the former; it can also
    be split into pieces.  Also added the bootloader_exclusive routine kind
    which is a system service that can only be called by a bootloader,
    examples being distinct transaction initiation and termination
    statements.  Most updates were in the ROUTINES and TRANSACTIONS AND
    CONCURRENCY and RESOURCE MODULARITY AND PERSISTENCE sections of
    Basics.pod, and in the DESCRIPTION of PTMD_Tiny.pod.

    * (Routines.pod)  Added new SYSTEM-DEFINED CORE BOOTLOADER EXCLUSIVES
    with 3 new sys.Core.Control.(start|commit|rollback)_trans routines.

    * (Basics.pod)  In the ENTITY NAMES section, refactored the
    fed|dep|sdp|pkg namespaces so that each has cat|lib|data secondary
    namespaces.  The 'lib' namespace retains the type and routine
    invocation names while 'data' now represents a dbvar and it replaces
    all the '<relvar>'; this change was made to emphasize the fact that
    there is just a single global variable (per scope) for user data, and
    that relvars are just pseudo-variable components of a dbvar.  The new
    'cat' secondary namespaces, each a dbvar, are now the parts of the
    system catalog for user-defined entities, and the 'cat' primary
    namespace is now just a dbcon for system-defined entities.  Added new
    'mnt' primary namespace catalog dbvar to countrol what depot mounts
    exist, rather than that being under the 'cat' primary.  Also indicated
    that type definitions can have inner routines, and routine definitions
    can have inner types; that is there are both inner and outer types now.

    * (Basics.pod)  In ENTITY NAMES, added "Terse Pseudo-Variable Syntax"
    section which specifies that you can indeed use extended entity names
    to directly reference components of eg tuples, such as by writing
    "tupvar.attrname" rather than having to say "attr( tupvar, attrname )"
    or "assign( tupvar.attrname, 42 )" rather than "assign( tupvar,
    update_attr( tupvar, attrname, 42 ) )".

    * (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Formalized
    the Cat.NameChain type with actual possrep names, and updated it to
    require a minimum of 2 chain elements; also deleted the superfluous
    types Cat.NESeqOfName and Cat.FlattenedNameChain, which have been
    merged into Cat.NameChain as informal inner types.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Supplemented the HDMD_Perl_Tiny
    dialect so you can define whole bootloader routines in it as you
    already could with the PTMD_Tiny dialect; added 2 new pod sections /
    PHMD node types BOOTLOADER and BOOTLOADER PROCEDURE CALL.  Updated the
    PTMD_Tiny dialect to rename the 'start' token to 'bootloader', and
    'procedure_call' to 'bootloader_procedure_call'; the latter now starts
    with the literal text 'boot_call' rather than 'Call'.

2008-04-13  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.25.1 is released on CPAN as
    Muldis-D-0.25.1.tar.gz.

    * New file versions are: D.pm 0.25.1 and Basics.pod 0.18.1 and
    SeeAlso.pod 0.4.1.  The other pre-existing versioned files are
    unchanged.

    * (D.pm, Basics.pod, SeeAlso.pod)  A few minor updates to reflect the
    fact that the Muldis D main reference implementation is now named
    Muldis Rosetta rather than Muldis DB.

2008-04-07  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.25.0 is released on CPAN as
    Muldis-D-0.25.0.tar.gz.

    * New file versions are: D.pm 0.25.0 and Types.pod and
    Types_Catalog.pod and Ordered.pod and Integer.pod and Blob.pod and
    Text.pod and Set.pod and Sequence.pod and Bag.pod and Rational.pod
    0.22.0 and Basics.pod 0.18.0 and PTMD_Tiny.pod 0.17.0 and
    HDMD_Perl_Tiny.pod 0.14.0 and Temporal.pod and Spatial.pod 0.7.0.  The
    other pre-existing versioned files are unchanged.

    * (D.pm)  The TRADEMARK POLICY section was severely edited to excise
    most legalese, and is now just half its previous size; the old longer
    version was shunted off to the Muldis Data Systems' website.

    * (D.pm, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Renamed the quasi-constant
    second (authority) part of a fully-qualified name format for a Muldis D
    language variant, applicable only to the official/original (not
    embraced and extended) variants, from 'cpan:DUNCAND' to
    'http://muldis.com'.  This is because the main web address of Muldis
    Data Systems more closely represents the official authority on Muldis
    D, rather than CPAN which is more just a forum for publishing it.

    * (Basics.pod, PTMD_Tiny.pod)  Updated the "main" routine kind to
    specify that it can not have any lexical variables or inner routines;
    all a "main" can do is invoke procedures that have no subject-to-update
    parameters.

    * (Basics.pod)  The standard system-defined entities may now have fully
    qualified names that are 3 or more parts (including the "sys") rather
    than exactly 4 parts, which allows for more elegant naming schemes.

    * (Types.pod, Types_Catalog.pod, HDMD_Perl_Tiny.pod, Integer.pod,
    Blob.pod, Text.pod, Rational.pod, Temporal.pod, Spatial.pod)  Renamed
    all the data types declared in Types.pod to substitute 'Type' for
    '(Universal|((|Quasi)(Scalar|Tuple|Relation)|Remnant|Spec)'; then
    renamed the 4 'D0' types to distinguish them again, and renamed 'E_D'
    to 'QuasiScalarDVPT'.  Renamed all the data types declared in
    Types_Catalog.pod to insert a '.Type' before their '.(|Quasi)Cat'.
    Then all the Core types were named 'sys.Core.Type(|.(|Quasi)Cat).\w+'.
    Renamed all the data types declared in
    (Integer|Blob|Text|Rational|Spatial).pod so that they have names like
    'sys.<extension>.Type.\w+'; the previous 3rd name part was either
    redundant with the extension name or was '(Cat|Spec)'.  Renamed all the
    data types declared in Temporal.pod from 'sys.Temporal.(With|No)TZ.\w+'
    to 'sys.Temporal.Type.\w+(With|No)TZ'.

    * (Ordered.pod, Integer.pod, Blob.pod, Text.pod, Set.pod, Sequence.pod,
    Bag.pod, Rational.pod)  Renamed all the routines whose third name parts
    were redundant with their second name parts, to remove the third parts.

    * (Types.pod, Integer.pod, Rational.pod)  Removed the system-defined
    types NE(Blob|Text) and updated the few system-defined functions using
    them to use Blob|Text instead.

    * (Types_Catalog.pod, Integer.pod, Rational.pod)  Removed the
    Cat.PInt2_36 type from the core and placed duplicate copies of it under
    altered names in both the integer and rational extensions.

    * (Types_Catalog.pod)  Updated the DESCRIPTION, as well as the Name and
    Comment descriptions.

    * (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Updated the
    Cat.E_ENK and Cat.E_PSAK types to remove each of their 'default'
    values.  Users now always specify the use of type-default values
    explicitly, using either generic literal or function invocation
    expressions, which makes user code more self-documenting and saves on
    some catalog complexity; that said, some Muldis D dialects may still
    have a short-hand for 'default'.

    * (Types_Catalog.pod)  Updated the Cat.ExprNode and Cat.ProcStmtArg
    types to remove each of their 'type' attributes.  Users now always do
    an explicit 'treated' func call when they need to, or otherwise the
    data type at each of these nodes is now just inferred from context, and
    so Muldis D is now more like a typical programming language as to what
    it requires users to explicitly say.

2008-03-22  Darren Duncan <perl@DarrenDuncan.net>

    * Muldis::D version 0.24.0 is released on CPAN as
    Muldis-D-0.24.0.tar.gz.

    * What was Language-MuldisD at version 0.23.0 has been renamed to
    Muldis-D.  This is the first release of the Muldis-D distribution, and
    the first release of any distribution to contain Perl 5 package names
    like Muldis::D(|::\w+).  All of the files in this distribution are as
    identical as possible to how they were when last released under the
    names Language::MuldisD(|::\w+) but for the name changes.  All lib/
    files were renamed appropriately, and also the one t/LMD_00_Compile.t
    was renamed to t/Muldis_D_00_Compile.t.

    * All versioned files had their version numbers incremented to the
    first higher 0.N.0.  New file versions are: D.pm 0.24.0 and Core.pod
    and Types.pod and Types_Catalog.pod and Routines.pod and Ordered.pod
    and Integer.pod and Blob.pod and Text.pod and Nonscalar.pod and Set.pod
    and Sequence.pod and Bag.pod and Rational.pod 0.21.0 and Basics.pod
    0.17.0 and PTMD_Tiny.pod 0.16.0 and HDMD_Perl_Tiny.pod 0.13.0 and
    Temporal.pod and Spatial.pod 0.6.0 and SeeAlso.pod 0.4.0 and
    Hierarchical.pod and Conventions.pod 0.1.0.

    * Updated D.pm and the README file to clarify that commercial support
    is available from the author specifically by way of Muldis Data
    Systems.

    * Updated all .pm and .pod files to add a new TRADEMARK POLICY section
    near the end of each; it serves for trademarks what the LICENSE AND
    COPYRIGHT did for copyrights.  The D.pm file had the actual text, and
    the other files simply say to look at D.pm.  To summarize, the word
    MULDIS is a trademark and how you may use it has limitations.

    * (SeeAlso.pod)  Updated the "Muldis DB for Perl 6" implementation
    reference to say that it is now a secondary version, and that the Perl
    5 version is now the only main muldis D implementation.  Generally
    speaking, it does not help the adoption of Muldis D if we are giving
    the impression that it has a dependency that most people don't have
    and/or isn't ready for production use, namely Perl 6, and Perl 5 should
    be given more support in the meantime.

    * (Basics.pod, Ordered.pod)  Minor fixes.

    * This is the Muldis-D-0.24.0 file manifest:

        Changes
        INSTALL
        lib/Muldis/D.pm
        lib/Muldis/D/Basics.pod
        lib/Muldis/D/Conventions.pod
        lib/Muldis/D/Core.pod
        lib/Muldis/D/Core/Routines.pod
        lib/Muldis/D/Core/Types.pod
        lib/Muldis/D/Core/Types_Catalog.pod
        lib/Muldis/D/Dialect/HDMD_Perl_Tiny.pod
        lib/Muldis/D/Dialect/PTMD_Tiny.pod
        lib/Muldis/D/Ext/Bag.pod
        lib/Muldis/D/Ext/Blob.pod
        lib/Muldis/D/Ext/Integer.pod
        lib/Muldis/D/Ext/Nonscalar.pod
        lib/Muldis/D/Ext/Ordered.pod
        lib/Muldis/D/Ext/Rational.pod
        lib/Muldis/D/Ext/Sequence.pod
        lib/Muldis/D/Ext/Set.pod
        lib/Muldis/D/Ext/Spatial.pod
        lib/Muldis/D/Ext/Temporal.pod
        lib/Muldis/D/Ext/Text.pod
        lib/Muldis/D/Hierarchical.pod
        lib/Muldis/D/SeeAlso.pod
        LICENSE/GPL
        Makefile.PL
        MANIFEST
        MANIFEST.SKIP
        META.yml
        README
        t/Muldis_D_00_Compile.t
        TODO

2008-03-22  Darren Duncan <perl@DarrenDuncan.net>

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

      modid:       Muldis::D
      DSLIP:       cmong
      description: Formal spec of Muldis D relational DBMS lang
      userid:      DUNCAND (Darren Duncan)
      chapterid:   7 (Database_Interfaces)
      enteredby:   BDFOY (brian d foy)
      enteredon:   Sat Mar 22 22:41:26 2008 GMT

    The resulting entry will be:

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

2008-03-22  Darren Duncan <perl@DarrenDuncan.net>

    Record update in the PAUSE modules database:

           modid: [Language::MuldisD]
           statd: [c]
           stats: [m]
           statl: [o]
           stati: [n]
           statp: [g]
     description: [Formal spec of Muldis D relational DBMS lang]
          userid: [DUNCAND]
       chapterid: [7]
        mlstatus: [delete] was [list]

2008-03-05  Darren Duncan <perl@DarrenDuncan.net>

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

    * Reverted the only change made in release 0.22.1, by recombining the 6
    files Core(|/\w+).pod back into the single file Core.pod; it would then
    be split apart again but in a different way.  For simplicity of
    documentation, the rest of the release 0.23.0 change items are written
    from the point of view of starting with the combined Core.pod.

    * Pulled apart Core.pod to turn as much of it as possible into language
    extensions, leaving the remaining core as minimalist as possible, such
    that it contains barely more than what is needed to both bootstrap the
    Muldis D language and satisfy the mandatory parts of "The Third
    Manifesto".  The minimized core still provides the full system catalog
    complexity, but has relatively few system-defined generic data types
    and system-defined operators.  There were 9 new Ext/\w+.pod files
    created out of the reductions: Ordered.pod, Integer.pod, Blob.pod,
    Text.pod, Nonscalar.pod, Set.pod, Sequence.pod, Bag.pod, Rational.pod.
    Details of what each contains appear below.

    * Re-split apart Core.pod 4 ways, into itself and 3 new files, all of
    which have the same names of and correspond to the files of the same
    names that release 0.22.1 had: Types.pod, Types_Catalog.pod,
    Routines.pod.  In that respect, then, release 0.23.0 actually served to
    just eliminate the 2 files Functions_(S|Nons)calar.pod, whose contents
    were either merged into Routines.pod or spread out into the 9 new Ext
    files; and some smaller portions of Types(|_Catalog).pod were also
    moved out into some of the 9 new Ext files.  Details pre-split follow.

    * New file versions are: MuldisD.pm 0.23.0 and Core.pod and Types.pod
    and Types_Catalog.pod and Routines.pod and Ordered.pod and Integer.pod
    and Blob.pod and Text.pod and Nonscalar.pod and Set.pod and
    Sequence.pod and Bag.pod and Rational.pod 0.20.0 and Basics.pod 0.16.0
    and PTMD_Tiny.pod 0.15.0 and HDMD_Perl_Tiny.pod 0.12.0 and Temporal.pod
    0.5.3.  The other pre-existing versioned files are unchanged.

    * (Ordered.pod, Core.pod, Temporal.pod)  Removed the Ordered union
    type; from now on, any type is potentialy orderable based on what
    functions exist for it, not by its type declaration.  Also removed the
    4 Spec.\w+ofOrdered types.  Any routine declarations that used Ordered
    before now use Universal instead.  Moved all sys.Core.Ordered.\w+
    functions to Ordered.pod from Core.pod, renaming them to
    sys.Ordered.Ord.\w+.

    * (Core.pod)  Removed the Cat.ScalarLiteral type; from now on, the
    limitations of what values can be used for the scal_lit attribute of
    Cat.ExprNode are either dialect-defined or implementation-defined; all
    others can still be defined using the 'func' attribute.

    * (Basics.pod, Rational.pod, Core.pod, PTMD_Tiny.pod,
    HDMD_Perl_Tiny.pod)  Demoted the Rat types from the language core into
    a language extension.  Moved all sys.Core.Rat.\w+ types (plus the
    sys.Core.Spec\w+ofRat types) and functions to Rational.pod from
    Core.pod, renaming the 'Core' to 'Rational'. Likewise moved and renamed
    the 3 rational-specific catalog types [PInt2_N, E_RM, RatRoundRule].
    Updated Basics.pod to reflect this.  Rearranged PTMD_Tiny.pod and
    HDMD_Perl_Tiny.pod to move their elements for Rat and E_RM literals to
    the end of the files, where language extension literals now go.

    * (Integer.pod, Core.pod) Moved all sys.Core.Int.\w+ functions (plus
    the sys.Core.Spec\w+of(Int|UInt) types) to Integer.pod from Core.pod,
    renaming the 'Core' to 'Integer'.

    * (Blob.pod, Core.pod) Moved all sys.Core.Blob.\w+ functions (plus the
    sys.Core.Spec\w+ofBlob types) to Blob.pod from Core.pod, renaming the
    'Core' to 'Blob'.  Likewise moved and renamed the blob-specific catalog
    type PInt1_4.

    * (Text.pod, Core.pod) Moved all sys.Core.Text.\w+ functions (plus the
    sys.Core.Spec\w+ofText types) to Text.pod from Core.pod, renaming the
    'Core' to 'Text'.

    * (Core.pod, HDMD_Perl_Tiny.pod)  Renamed all 8
    sys.Core.(Bool|Int|Text|Blob).\w+ remaining types to
    sys.Core.Scalar.\w+.  So now all the generic core types have names in
    the just 8 main type groupings: Scalar, Tuple, Relation, their 3 Quasi
    counterparts, Universal, Remnant.

    * (Core.pod)  Removed the 4 Spec.\w+ofScalar types.  So now the only
    similar such types left in the core are the 4 Spec.\w+ofBool ones;
    collapsed the mention of them under TYPE SUMMARY into a footnote.

    * (Nonscalar.pod, Core.pod)  Moved 31 (about 3/7) of the
    sys.Core.(Tuple|Relation).\w+ functions to Nonscalar.pod from Core.pod,
    renaming the 'Core' to 'Nonscalar'.  The moved were in 5 groups, the
    first being all Tuple.\w+, the remaining 4 all Relation.\w+.  Group 1
    had these 4: degree, attr_from_Tuple, Tuple_from_attr,
    substitution_in_default.  Group 2 had these 11: degree,
    is(|_not)_empty, empty, universal, power_set, negation,
    transitive_closure, (|maybe_)reduction, map.  Group 3 had these 5:
    is(|_not)_proper_subset, exclusion, composition, join_with_group. Group
    4 had these 6: (|static_)substitution(|_in_(restriction|semijoin)).
    Group 5 had these 5:
    outer_join_with_(group|maybes|defaults|product|extension).

    * (Set.pod, Core.pod) Moved all sys.Core.(Set|Maybe).\w+ functions to
    Set.pod from Core.pod, renaming the 'Core' to 'Set'.

    * (Sequence.pod, Core.pod) Moved all sys.Core.Seq.\w+ functions to
    Sequence.pod from Core.pod, renaming the 'Core' to 'Sequence'.

    * (Bag.pod, Core.pod) Moved all sys.Core.Bag.\w+ functions to Bag.pod
    from Core.pod, renaming the 'Core' to 'Bag'.

    * Following all the above moves, there were 56 operators (53 functions,
    1 updater, 2 procedures) remaining in Core.pod; of those, the
    'Universal' namespace had 5 functions and 1 updater, the 'Bool'
    namespace had 6 functions, the 'Tuple' namespace had 10 functions, the
    'Relation' namespace had 33 functions, and the 'Control' namespace had
    2 procedures.

2008-02-29  Darren Duncan <perl@DarrenDuncan.net>

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

    * This release takes place on a rare February 29th.

    * This release is minimalist and serves only to split up the file
    Core.pod into itself plus 5 new files, all named Core/\w+.pod:
    Types.pod, Types_Catalog.pod, Routines.pod, Functions_Scalar.pod,
    Functions_Nonscalar.pod.  This split was done mainly to make the
    information easier to maintain and to read.  Where the original file
    was 168KB, the largest of the new files is 60KB.

    * New file versions are: MuldisD.pm 0.22.1 and Core.pod 0.19.1 (all 5
    Core/\w+.pod started at 0.19.1 also).  The other pre-existing versioned
    files are unchanged.

2008-02-26  Darren Duncan <perl@DarrenDuncan.net>

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

    * New file versions are: MuldisD.pm 0.22.0 and Core.pod 0.19.0 and
    Basics.pod 0.15.0 and PTMD_Tiny.pod 0.14.0 and HDMD_Perl_Tiny.pod
    0.11.0.  The other pre-existing versioned files are unchanged.

    * (Basics.pod)  Added new "Numeric Types" pod subsection under TYPE
    SYSTEM, which outlines what features concerning numeric data are and
    are not provided by the Muldis D language core.  To summarize, the core
    numerics are all exact radix-independent "bignum", suitable for all
    magnitude of rational or floating-point numbers; no special values like
    NaNs or infinities are provided, they are left to language extensions.

    * (Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Renamed the rounding
    method 'to_even' to 'half_even' and added 2 more rounding methods
    'half_down' and 'to_inf'; the 2 complement 'half_up' and 'to_zero'.

    * (Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Enhanced the Rat
    numeric type so it now has 2 actual possreps, defined over Ints, called
    'ratio' (2 attrs) and 'float' (3 attrs), rather than having zero actual
    possreps and just a conceptual ratio one.  The 'float' possrep is
    intended to make it easier to deal with numbers in scientific notation,
    which is particularly useful for very large or very small numbers.
    Added the 4 functions Rat.Rat_from_Int_triple and
    Rat.(mantissa|radix|exponent) to reflect the 'float' possrep.  (But
    note that these such functions are deprecated for generic scalar ones.)
    In PTMD_Tiny, added a third format for specifying Rat literals, named
    'float', which looks like 'Rat:float:9:314159*10^-5'; also renamed the
    'pair' format to 'ratio'.  In HDMD_Perl_Tiny, updated the PHMD node for
    Rat literals to add some 'float' formats and rename the 'pair' formats.

2008-02-15  Darren Duncan <perl@DarrenDuncan.net>

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

    * New file versions are: MuldisD.pm 0.21.0 and Core.pod 0.18.0 and
    Basics.pod 0.14.1 and PTMD_Tiny.pod 0.13.0 and HDMD_Perl_Tiny.pod
    0.10.0.  The other pre-existing versioned files are unchanged.

    * (MuldisD.pm, Basics.pod)  Updated the paradigm list of Muldis D to
    add the word "homoiconic", which I just learned about today and which
    is strongly descriptive of any "D" language, especially of Muldis D.

    * (Basics.pod, Core.pod)  Renamed the 'treat' function to 'treated';
    renamed the 'v' parameter of that and the 'is_value_of_type' function
    to 'topic'.

    * (Core.pod)  Updated the notes on a complete tuple|relation types'
    cardinalities to say specifically how to calculate them, rather than
    generally saying it is done using permutations.

    * (Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Added new scalar
    catalog data type sys.Core.Cat.Comment which represents a Muldis D code
    comment that programmers can attach to various catalog elements; it is
    also useful for preserving comments translated to/from other languages.
    This type is the same as Text|Name but is disjoint from both.  Also
    added a new Comment token or PHMD node type to both Tiny dialects.

    * (Core.pod)  Updated most (11) of the tuple catalog types to add a
    'comment' attribute to each, so code comments can be attached to code
    in the most appropriate places possible, such as to individual
    expression nodes or to whole statements or to whole routines.

    * (Core.pod)  Updated the 2 functions sys.Core.Relation.un(wrap|group)
    to add the new 'inner' argument, which resolves ambiguity of what
    attribute names are being added for the result when the input relation
    has no tuples (and the MST of every input relation attribute is Empty).

    * (Core.pod)  Added the 4 functions
    Relation.static_(extension|substitution(|_in_(restriction|semijoin)))
    which are all simpler-syntax versions their 'static_'-less counterparts
    where the values being added or substituted are the same for every
    tuple, so there is no need to incur a conceptual function call per
    input tuple.  So now every Muldis D function with a function parameter
    now has an alternate specialized variant which handles certain common
    cases, without a function parameter.

    * (Core.pod)  Added the function sys.Core.Tuple.multi_update as a
    short-hand for multiple update_attr; in fact it is necessary in cases
    where the latter would otherwise be used but a type constraint would
    require multiple attribute updates as a unit.

    * (Core.pod)  Added the function sys.Core.Tuple.substitution_in_default
    which should help users write less verbose Muldis D code where they can
    just specify parts of a desired tuple value and let the rest be filled
    in with default attributes for the desired tuple's type.

    * (PTMD_Tiny.pod)  Updated specifier for called procedure name so it
    can be in both formats that a Cat.NameChain can have.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Added support for
    quasi-nonscalar literals as per nonscalar literals.

2008-02-07  Darren Duncan <perl@DarrenDuncan.net>

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

    * New file versions are: MuldisD.pm 0.20.0 and Core.pod 0.17.2 and
    Basics.pod 0.14.0 and PTMD_Tiny.pod 0.12.0 and HDMD_Perl_Tiny.pod 0.9.0
    and SeeAlso.pod 0.3.4.  The other pre-existing versioned files are
    unchanged.

    * (MuldisD.pm, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Renamed the constant
    first part of a fully-qualified name format for a Muldis D language
    variant, from 'MuldisD' to 'Muldis_D'.  This is to help not perpetuate
    the myth that the normal/correct way to spell the language name is with
    MuldisD (1 word) rather than Muldis D (2 words); I have already seen a
    number of places using that shortened form, incorrectly.  Note that the
    only reason the package name has them rammed together is because that
    is normal practice for Perl namespaces, which the spec is written
    under.

    * (Basics.pod, Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod,
    SeeAlso.pod)  Rewrote the "Representation" POD sub-section of the
    "MULDIS D" POD main section of Basics.pod, which included renaming the
    "Concrete" and "Abstract" dialect groupings to "Plain Text" and "Hosted
    Data".  Then renamed any references to said groupings in all 5 files.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Rewrote most of the DESCRIPTION
    pod in light of both the "Representation" change and MuldisD.pm's new
    VERSIONING section, to conform to them and remove redundancies.  Also
    smaller changes for the same reasons in other parts of the 2 Tiny
    files.  In HDMD_Perl_Tiny.pod, split the GENERAL STRUCTURE pod section
    into itself and LANGUAGE NAME, the latter portion being rewritten.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Shortened the syntax for a
    Cat.Name value, which huffmanizes the grammars more and also allows
    other improvements.  The cat_name grammar token no longer specifies a
    "Cat.Name:" prefix, and the Cat.Name phmd node is now simply a Perl Str
    rather than being a 2-element Array; any parsing context that is
    expecting a generic literal grammar token or generic phmd node will
    interpret a character string without metadata as being a Cat.Name.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Updated every nonscalar literal
    grammar token and phmd node to remove its element that specifies a
    predefined type name which constrains/defines the literal's heading.
    This meta-data was verbosity that couldn't really be used except within
    the DBMS, wherein it already existed there in code definitions that is
    processing the literals.  As an exception to this straight-removal, for
    plain relation literals, a new replacement feature was added for the
    removed, which specifies the relation's attribute list when the
    relation has no tuples to provide that information.  Given that this
    attribute list is formatted differently than a tuple list, just one of
    those things appears in a relation literal, and a parser can easily
    distinguish between them.

    * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod)  Fleshed out or fixed the
    syntaxes for specifying Cat.NameChain literals.

    * (PTMD_Tiny.pod)  Added the syntax to call procedures, thus making a
    PTMD_Tiny code file actually able to represent a Muldis D 'main'
    routine, and hence actually represent a program; which is simply a
    sequence of procedure calls following a language name declaration.  The
    literal-defining syntax which still makes up most of the grammar is now
    specifically for defining arguments for the procedure calls

2008-02-07  Darren Duncan <perl@DarrenDuncan.net>

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

    * This release is very minimalist, serving to rename a few files, and
    do as little as possible otherwise.  It seemed best to do all actual
    file content changes separately, so that it is easy to do
    same-file-name diffs on consecutive distro versions and see what
    content changed.

    * Renamed Grammar.pod to Dialect/PTMD_Tiny.pod, and PerlHosted.pod to
    Dialect/HDMD_Perl_Tiny.pod.  Correspondingly renamed the pseudo-package
    names (what the NAME pod says) in those files.  Then updated all the
    other distro files to refer to the 2 renamed by their new names.

    * New file versions are: MuldisD.pm 0.19.1 and Core.pod 0.17.1 and
    Basics.pod 0.13.1 and PTMD_Tiny.pod 0.11.1 and HDMD_Perl_Tiny.pod 0.8.1
    and Hierarchical.pod 0.0.3.  The other pre-existing versioned files are
    unchanged.

2008-02-03  Darren Duncan <perl@DarrenDuncan.net>

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

    * New file versions are: MuldisD.pm 0.19.0 and Core.pod 0.17.0 and
    Basics.pod 0.13.0 and Grammar.pod 0.11.0 and PerlHosted.pod 0.8.0 and
    Hierarchical.pod and Conventions.pod 0.0.2.  The other pre-existing
    versioned files are unchanged.

    * (MuldisD.pm)  Added new main pod section VERSIONING which explains
    the fully-qualified name formats of Muldis D variants in a generic
    manner, so to help make the Muldis D code more future-proof.  Updated
    the related DESCRIPTION paragraph.

    * (Basics.pod, Core.pod)  Renamed the 2 operators is(|_not)_equal to
    is(|_not)_identical, which is arguably less ambiguous on what they are
    testing for.  Also renamed their parameters from v(1|2) to
    (topic|other); the parameters are still commutative, though.

    * (Core.pod)  Renamed the 2 operators is_(increase|decrease_or_same) to
    is(|_not)_before, and eliminated the 2 operators
    is_(decrease|increase_or_same); considering that all Muldis D
    parameters are named rather than ordered, the eliminated operators are
    completely redundant with invoking the 2 kept ones with the arguments
    swapped, and order-specific variants are not helpful.  Also renamed
    their parameters as per the is_identical change.  This elimination also
    brings more parity with other parts of the language that considered
    only-position-swapped variants useless, such as the presence of
    is_subset but no is_superset.

    * (Core.pod, Grammar.pod, PerlHosted.pod)  Eliminated the Cat.Order
    type, which currently doesn't seem to be that useful after all (if this
    judgement was wrong, it could be brought back later).  Eliminated the
    corresponding grammar token and PHMD node kind.  Eliminated the 2
    Ordered.(|reverse_)comparison functions.  Eliminated the 4
    Cat.Order_\w+ functions.

    * (Core.pod, Grammar.pod, PerlHosted.pod)  Renamed the Just type to
    Single (and QuasiJust to QuasiSingle); while breaking from the
    Haskell-inspired triple, it reads better for Muldis D, and is more
    descriptive.

    * (Core.pod)  Added 3 functions sys.Core.Maybe.(nothing|single|attr)
    where the first 2 will select a Nothing or Single value respectively,
    and the last one will extract the payload of a known-Just value.

    * (Core.pod)  Renamed the 2 functions Int.(in|de)crease to
    Int.(in|de)crement.

    * (Core.pod)  Added an initial complement of 5 relational functions to
    do half-outer natural joins in different ways,
    Relation.outer_join_with_(group|maybes|defaults|product|extension);
    also added inner join variant of the first, Relation.join_with_group.
    The 2 'group' functions are intended as convenient tools for gathering
    both parent and child records from a database using a single query
    while avoiding duplication of the parent record values.

    * (Core.pod, Hierarchical.pod, Conventions.pod)  Other minor updates.

2008-01-25   Darren Duncan <perl@DarrenDuncan.net>

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

    * New file versions are: MuldisD.pm 0.18.0 and Core.pod 0.16.0 and
    Basics.pod 0.12.0 and Grammar.pod 0.10.0 and PerlHosted.pod 0.7.0 and
    Hierarchical.pod and Conventions.pod 0.0.1.  The other pre-existing
    versioned files are unchanged.

    * (Basics.pod)  Updated TYPE SYSTEM to remove the requirement where
    every value must have exactly one most-specific-type / MST, which is
    supposed to exist in a generic "D" language to assist some kinds of
    polymorphism.  Although that restriction is still generally followed
    for all system-defined types, and it would ideally be the case for all
    user-defined types, the design of Muldis D does not generally require a
    value to have a single MST in order to work, and moreover to enforce
    the single-MST requirement would place an undue burden on users, who
    would typically need to define many gratuitous types to satisfy it.

    * (Basics.pod)  Updated the "Tuple Types and Relation Types" subsection
    of TYPE SYSTEM to directly explain that any 2 zero-tuple relation
    values of the same degree and with the same attribute names are
    considered identical, regardless of the declared types of those
    attributes in the code that produced them; every attribute of a
    zero-tuple relation value has an MST of Empty, which is a subtype of
    every other type.  A consequence is that every Set|Maybe or Seq or Bag
    type's single zero-tuple value is identical to every other's one.

    * (Core.pod)  Further echoing the design of Haskell's "Maybe" feature,
    added 2 complementary subtypes of Maybe named
    sys.Core.Relation.(Nothing|Just), which have exactly zero tuples or 1
    tuple, respectively; the Nothing type has exactly 1 value of Maybe, and
    the Just type has all the rest of them.  Nothing is Muldis D's answer
    to the SQL NULL, in that it is meant as a marker that a value is
    unknown or inapplicable; but unlike SQL, Nothing is an actual value,
    and it does equal itself.  Just is the same container, that always does
    hold exactly one value.  Also added the 2 subtypes Quasi(Nothing|Just).

    * (Grammar.pod, PerlHosted.pod)  Took the explicit grammar token or
    PHMD node type specific to the Maybe type, and replaced it with two
    that are specific to the Nothing or Just types, where each
    more-specialized replacement has simpler syntax than what it replaced.

    * (Basics.pod, Core.pod, Grammar.pod, PerlHosted.pod)  Rounded out /
    added better symmetry to the type system by adding the concept of a
    quasi-scalar type and adding the system-defined QuasiScalar maximal
    type.  Since there are no normal system-defined quasi-scalar types from
    which that new maximal would draw a default value (all normal
    quasi-scalar types are expected to be user-defined, if they exist at
    all), also added the QuasiScalar.E_D subtype which exists soley for
    that purpose.  Also added the system-defined Remnant maximal type, and
    that already had the pre-existing ScaTupRel normal system-defined type
    from which to draw a default value.

    * (Core.pod)  Removed the ExprNode|ProcStmtArg attribute 'tk' and
    InnerFunc attribute 'result_tk', due to seemingly not being too useful.

    * (Core.pod)  Added constraint to trees of expression nodes or inner
    routines such that any node which is the sole tree root in its context
    must have the empty string as its name.  These 4 catalog data types now
    have that constraint added: ExprTree, Inner(Func|Updater|Proc)Tree.
    Removed the no-longer-needed 'root_\w+' attribute from each of these 4
    catalog data types: InnerFunc, Func, Updater, Proc.  Some small fixes.

    * (Core.pod)  Added the 2 functions Ordered.is_(in|de)crease_or_same,
    which are to is_(in|de)crease what '>='|'<=' are to '>'|'<'.  With this
    addition, all 6 of the common dyadic compare operators [=,!=,<,>,<=,>=]
    are directly represented, so no need to emulate over several functions.

    * (Core.pod)  Added the 3 functions Relation.disjoint_(insertion|union)
    and Set.disjoint_insertion; they are the same as the non-disjoint
    versions but that they fail if there are duplicate tuples|elements
    rather than succeeding as a full or partial no-op.

    * (Basics.pod, Core.pod, Hierarchical.pod, Conventions.pod)  Other
    minor updates.

2008-01-12   Darren Duncan <perl@DarrenDuncan.net>

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

    * New file versions are: MuldisD.pm 0.17.0 and Core.pod 0.15.0 and
    Grammar.pod 0.9.0 and PerlHosted.pod 0.6.0.  The other pre-existing
    versioned files are unchanged.  Added 2 new files
    lib/Language/MuldisD/Hierarchical.pod and
    lib/Language/MuldisD/Conventions.pod, each of which start at version
    0.0.0.

    * (Core.pod)  Updated the Cat.InnerFunc type to add a couple missing
    attributes, result_tk and result_type.

    * (Grammar.pod, PerlHosted.pod)  Removed the explicit grammar tokens or
    PHMD node types that were specific to these 7 Muldis D types: UInt,
    PInt, URat, PRat, NEBlob, NEText, Database.  So now just these 14 ones
    are directly supported: Bool, Int, Rat, Blob, Text, Tuple, Relation,
    Set, Maybe, Seq, Bag, Cat.Name, Cat.NameChain, Cat.Order.  This change
    was made to remove unnecessary complexity from the grammar/PHMD specs;
    now for the most part there is now only 1 distinct grammar token or
    PHMD node type for each core Muldis D root type (so the removed are
    covered by their remaining parents); non-root types generally only have
    their own when they also have a syntactic short-hand to take advantage
    of.  Any otherwise orphaned examples were updated to the parent syntax.
    Also removed the 'index' variant of Seq from Grammar, leaving just the
    ordered variant, which was all PerlHosted had anyway.  And updated the
    'count' variant of Bag to do itself what it had used a PInt token/node
    to do.

    * (Grammar.pod, PerlHosted.pod)  Upgraded the specification formats for
    rationals so that now any rational value can be directly selected, not
    just those whose denominators are powers of 2..36; for example, you can
    now select the rational 1/43 directly where you couldn't before.  To
    facilitate this, there are now 2 formats you can define a rational in,
    the previous 'N.N' format, called 'radix', and the new 'N/N' format,
    called 'pair'; in PerlHosted, the latter is given as 2 elements, not 1.

    * (Grammar.pod, PerlHosted.pod)  Added grammar tokens and PHMD node
    types for all the not yet covered enumerated scalar catalog types:
    Cat.E_RM, Cat.E_TK, Cat.E_TDM, Cat.E_ENK, Cat.E_PSAK.  So that fills in
    all the remaining gaps in those files and it is now possible to either
    directly select any Muldis D value or directly define the system
    catalog entries of any Muldis D code that would.

    * (Hierarchical.pod)  This new file has begun to outline an additional
    official dialect of Muldis D, which is terse and intended for normal
    use for writing code in, or writing code examples in, unlike the
    'catalog' dialect which is damningly verbose for normal use.

    * (Conventions.pod)  This new file is a style guide, and mainly starts
    off with suggesting good ways to name entities.

    * (Core.pod)  Other minor updates.

2008-01-05   Darren Duncan <perl@DarrenDuncan.net>

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

    * This release coincides with the 5th anniversary of the first CPAN
    release of the first Muldis D / Muldis DB progenitor; DBIx::Portable
    version 0.01 was released on 2003 January 5th.

    * New file versions are: MuldisD.pm 0.16.0 and Core.pod 0.14.0 and
    Basics.pod 0.11.0 and Grammar.pod 0.8.0 and PerlHosted.pod 0.5.0.  The
    other pre-existing versioned files have their version numbers all
    incremented by 0.0.1.

    * (Basics.pod, Core.pod)  Renamed the routine kinds update_operator and
    inner_update_operator to the shorter 'updater' and 'inner_updater',
    though the terms 'update operator' and 'updater' will continue to be
    interchangeable.  Also renamed 6 corresponding catalog types to
    UpdStmt, MultiUpdStmt, InnerUpdater, InnerUpdaterSet, InnerUpdaterTree,
    Updater, and renamed any referencing attributes as appropriate.

    * (Core.pod)  Reformatted all the routine signatures to look more
    natural for Muldis D, rather than being mostly identical to the Perl 6
    routine signature format.  The format for function declarations is now
    "function foo result Bar params { baz(Quux) }" rather than "foo of Bar
    (Quux $baz)", and the format for updater or procedure declarations is
    now "updater|procedure foo update { fi(Fum) } read { baz(Quux) }"
    rather than "foo (UPD: Fum $fi ; RO: Quux $baz)".  Note that this
    version may not be final, and another reformat may likely come, though
    that one would likely just consist of different keywords to replace
    [result, params, update, read] and not other changes; feedback on this
    is welcome.

    * (Core.pod)  Removed the 3 core pseudo-types
    sys.Core.Some.(Universal|ScaTupRel|Ordered), and added the 1 core
    remnant type sys.Core.Remnant.ScaTupRel; the new one replaces one of
    the removed, and the other 2 removed are now just redundant with the
    normal Universal and Ordered types.  It seemed rather arbitrary that
    some contexts (like routine signatures) which couldn't actually take
    all combinations of their parameter types would in some cases have said
    parameters documented as pseudo-types, other times as regular types.

    * (Core.pod, Grammar.pod, PerlHosted.pod)  Reversing one change made
    for release 0.9.0, a Cat.Name is once again allowed to be the empty
    string (like 'Text', not 'NEText'), and Cat.NameChain parts likewise.

    * (Core.pod, Grammar.pod, PerlHosted.pod)  Officially demoted the Order
    type from a generic type to a catalog-specific type, since it isn't
    really ever expected to be used in user data, but just routine
    definitions.  It was renamed from sys.Core.Order.Order to
    sys.Core.Cat.Order, and the definition of the type was moved from the
    generic scalars section to the catalog scalars section; it did not get
    further renamed to 'E_FOO' as Order is still more special than the
    average enum type as per the enum type Bool, if nothing else than for
    directly corresponding to a concept in multiple other programming
    languages such as Perl 6.  In Core.pod, added new main pod section
    SYSTEM-DEFINED CORE CATALOG FUNCTIONS and moved the Order routines
    there, renaming each of them from Order.foo to Cat.Order_foo in the
    process.  In Grammar.pod, renamed the 'order' token to 'cat_order' and
    moved it next to the existing catalog types; made other appropriate
    updates there, and updates and moves in PerlHosted.pod.

    * (Core.pod)  Updated any routine signatures that specified some
    collection-type parameters as Foo{Bar} so they spell it FooAsBar
    instead.  Also added a few explicitly system-defined Spec.FooOfBar that
    didn't previously exist but were referred to by said routines.

    * (Core.pod)  Renamed the 3 scalar types Spec.PInt(1_4|2_(N|36)) to
    Cat.PInt(1_4|2_(N|36)), moved to catalog types.

    * (Core.pod)  Renamed (from 'Spec') or added the following 9
    quasi-catalog incomplete types, which are used only as the declared
    types of some system-defined N-adic relational operators; all are in th
    new package 'sys.Core.QuasiCat': (Set|Bag)Of(Tuple|Relation), SetOfBag,
    MaybeOfTuple, SeqOfSeq, QuasiSetOf(Tuple|Relation).  Moved to a new doc
    section SYSTEM-DEFINED CORE QUASI-CATALOG PARAMETERIZED TYPES.

    * (Core.pod)  With the above 2 groups removed from 'Spec', that package
    is now simply for conveniently system-defined collection-of-scalar
    types that are likely to be used in user data, and many of which are
    the declared types of N-adic system-defined scalar operators.  Added
    any of the following 32 subtypes that didn't previously exist:
    sys.Core.Spec.(Set|Maybe|Seq|Bag)Of(Scalar|Ordered),
    sys.Core.Spec.(Set|Maybe|Seq|Bag)Of(Bool|Int|UInt|Rat|Blob|Text).

    * Brought the TODO file in line with recent progress, replacing the few
    broad-scope line items with more detail-scope ones, added some
    speculation items.

    * Incremented all copyright year range-ends to 2008.

    * (Core.pod)  Other minor updates.

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

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

    * New file versions are: MuldisD.pm 0.15.0 and Core.pod 0.13.0 and
    Basics.pod 0.10.3.  The other pre-existing versioned files are
    unchanged.

    * (Core.pod)  Renamed the type sys.Core.Int.PInt2_N to
    sys.Core.Spec.PInt2_N and moved its declaration downwards.

    * (Core.pod)  Generally speaking, Muldis D now requires that for any
    defined relation type, there is a corresponding (same heading) tuple
    type also defined; the reverse is not true, though.  To be specific,
    any relation type is defined over the type that its tuples must be; a
    tuple type definition covers the minimal required relational heading.

    * (Core.pod)  Added the 6 tuple type factories
    (|Quasi)(Set|Seq|Bag)Elem, which have the same headings as the 6
    existing relation type factories (|Quasi)(Set|Seq|Bag).

    * (Core.pod)  Renamed Cat.(|SetOf)NameMap to Cat.(|SetOf)NameExprMap,
    and renamed its attributes from 'key','value' to 'name','expr'.  Also,
    as a reversal of one change made for release 0.8.0, renamed
    Cat.BiDiNameMap to Cat.AttrRenameMap, and renamed its attributes from
    'key','value' to 'before','after'.  The latter is therefore no longer a
    subtype of (the first of) the former.

    * (Core.pod)  Fleshed out the catalog types so that they can now fully
    define expression trees and functions (except where new data types are
    also required).  Renamed the enumerated type Cat.E_EK to Cat.E_ENK.
    Renamed the tuple type Cat.Expr to Cat.ExprNode, and added a 9th 'tk'
    attribute to it.  Added 6 new tuple|relation catalog types Cat.ExprSet,
    Cat.ExprTree, Cat.InnerFunc, Cat.InnerFuncSet, Cat.InnerFuncTree,
    Cat.Func.

    * (Core.pod)  Fleshed out the catalog types so that they can now fully
    define multi-update statements and multi-update operators (as per
    above).  Building on the expr/func stuff, added 6 new tuple|relation
    catalog types Cat.UpdateStmt, Cat.MultiUpdateStmt, Cat.InnerUpdateOper,
    Cat.InnerUpdateOperSet, Cat.InnerUpdateOperTree, Cat.UpdateOper.  Also
    added 2 more values to the Cat.E_ENK type, '(upd|ro)_param', and then
    generalized Cat.Expr so it can be used with subject-to-update
    params/args to define pseudo|virtual-variables.  So the composition of
    an update operator definition is mostly expression nodes like with the
    composition of functions.  Note that presumably the Muldis D provision
    of updateable virtual relvars (aka SQL's "views") would be provided as
    an abstraction over functions and update operators, or some such.

    * (Core.pod)  Fleshed out the catalog types so that they can now fully
    define non-atomic statements and procedures (as per above).  Building
    on the expr/func/upd stuff, added 1 new scalar catalog type Cat.E_PSAK
    and 7 new tuple|relation catalog types Cat.ProcStmtArg,
    Cat.ProcStmtArgSet, ProcStmt, Cat.SeqOfProcStmt, InnerProc,
    Cat.InnerProcTree, Cat.Proc.

    * (Core.pod)  Added 8 generic reduction operators
    'sys.Core.(Relation|Set|Seq|Bag).(|maybe_)reduction', so users can more
    easily write their own N-adic reduction operators.

    * (Core.pod)  Added initial complement of 11 Seq-specific functions,
    besides the 2 aforementioned: 'value', 'update_value', 'insertion',
    'deletion', 'is_element', 'is_not_element', 'catenation', 'repeat',
    'reverse', 'is_subseq', 'is_not_subseq'.

    * (Basics.pod, Core.pod)  Other minor updates.

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

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

    * This release coincides with the 20th birthday of Perl; Larry Wall
    released Perl 1 to the public on 1987 December 18th.  Moreover, on this
    20th birthday is the general/stable release of Perl 5.10, its best yet.

    * New file versions are: MuldisD.pm 0.14.0 and Core.pod 0.12.0 and
    Basics.pod 0.10.2 and Grammar.pod 0.7.2 and PerlHosted.pod 0.4.2.  The
    other pre-existing versioned files are unchanged.

    * (Basics.pod)  Small updates to the ROUTINES main section.

    * (Core.pod, Grammar.pod, PerlHosted.pod)  Added 4 new trivial data
    type definitions 'sys.Core.(|Quasi)(Tuple|Relation).D0', some of which
    were previously referenced but not defined; also corrected any
    references that said 'D0C(0|1)' to just say'D0'.

    * (Core.pod)  Added new pseudo-type sys.Core.Some.ScaTupRel, which is
    essentially a union type over Scalar|Tuple|Relation; it is for tersely
    refering to the general type of a scalar|tuple|relation attribute.

    * (Core.pod)  Added 3 new Int functions, 'increase' and 'decrease'
    (meaning '++' and '--'), and 'factorial'.

    * (Core.pod)  Added 2 new Tuple functions 'attr_from_Tuple' and
    'Tuple_from_attr', which work with degree-one tuples; they are
    analagous to the 2 "(T|R) from (R|T)" Relation functions that work with
    cardinality-one relations.  Also added 2 new Tuple functions 'attr' and
    'update_attr', which read or write an attribute in an arbitrary tuple.

    * (Core.pod)  Added new Relation function 'power_set', which results in
    a Set of all subsets of its Relation argument (which could itself be
    just a Set).  (Note: Not sure whether or not this is actually useful.)

    * (Core.pod)  Added descriptions to the Relation functions
    group|ungroup, updated those of tuple wrap|unwrap.  Added 3 new
    complementary tuple|relation functions cmpl_wrap|cmpl_group.

    * (Core.pod)  Fleshed out the Relation function 'substitution', and
    added 2 new relational functions,
    'substitution_in_(restriction|semijoin)'.  While 'substitution' will
    transform all tuples unconditionally, the 2 new 'in' functions let one
    keep the substitutions within a subset of the tuples.

    * (Core.pod)  Added new Relation function 'map', which provides a
    convenient one-place generalization of per-tuple transformations that
    otherwise might require the chaining of up to a half-dozen other
    operators like restriction, extension, and rename; like Perl's "map",
    or SQL's generic select-list.

    * (Core.pod)  Fleshed out the Relation function 'summary', giving it a
    full parameter list and description.  Note that this function is only
    intended to be used in situations where the corresponding SQL would
    involve a GROUP BY, and there is to be one result tuple per group,
    which also means an empty result relation from an empty input relation.
    Those who want their summary to be one tuple for the entire input, even
    an empty one, would just invoke the N-adic / aggregate operators
    directly without doing it by way of 'summary'.

    * (Core.pod)  Added 2 new Relation functions 'is_(|not_)proper_subset'.

    * (Core.pod)  Added initial complement of 6 Set-specific functions:
    'is_member', 'is_not_member', 'insertion', 'deletion', 'Set_from_wrap',
    'Set_from_attr'.  The first 4 are just short-hands for their Relation
    counterparts, having tuple attribute values as parameters rather than
    whole tuples.  The 'Set_from_attr' is intended to be the most
    convenient way to pull out values from an attribute for feeding to an
    aggregate function; it is short-hand for simple relational operations.
    The 'Set_from_wrap' ought to be convenient for other reasons, or if not
    then its counterparts under Bag or Seq perhaps will be.

    * (Core.pod)  Added initial complement of 2 Maybe-specific functions:
    'attr_or_default', 'attr_or_value'.  They are intended to be like
    Perl's defined-or functions, resulting in their only/main argument's
    content if it isn't empty, or a default value / second argument if it
    is; alternately these are like SQL's 2-argument COALESCE or NVL or
    IF_NULL etc; these should be useful in defining outer-joins.

    * (Core.pod)  Added initial complement of 17 Bag-specific functions:
    'is_member', 'is_not_member', 'insertion', 'deletion', 'Bag_from_wrap',
    'Bag_from_attr', 'cardinality', 'is_subset', 'is_not_subset',
    'is_proper_subset', 'is_not_proper_subset', 'union', 'intersection',
    'difference', 'count', 'Set_from_Bag', 'Bag_from_Set'.  The first 6 are
    as per the 6 set-specific functions.  The next 8 are as per the
    same-named Relation functions but that they have special semantics that
    take > 1 multiplicity of values into account; the Relation ones work as
    is for Set, but not as typically desired for Bag.  Then 'count' says
    how many occurrances (which may be zero) of a value are in a Bag.  The
    last 2 are short-hands for moving data between Set and Bag types.

    * (Core.pod)  Other minor updates.

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

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

    * As of this release, the in-code $VERSION declarations of all Perl 5
    packages in this distribution are changed to match the X.Y.Z format
    that the same packages' own VERSION POD had all along (the old in-code
    format was X.00Y00Z).  A consequence of this change is that this
    distribution has gained an external dependency on the Perl 5 module
    'version', which is not bundled with Perl 5.8.x; however, it *is*
    bundled with Perl 5.10.x, so if you are using that newer Perl, you
    won't have to install 'version' separately from CPAN.

    * New file versions are: MuldisD.pm 0.13.0 and Core.pod 0.11.0.  The
    other pre-existing versioned files are unchanged.

    * (Core.pod)  Renamed some tuple|relation functions so they describe
    the function's result rather than its action, or are otherwise more
    improved; that is, they are less verbs and more nouns or adjectives:
    'exists' => 'is_member', 'insert' => 'insertion', 'delete' =>
    'deletion', 'evacuate' => 'empty', 'project' => 'projection', 'remove'
    => 'cmpl_projection', 'tclose' => 'transitive_closure', 'restrict' =>
    'restriction', 'extend' => 'extension', 'summarize' => 'summary',
    'substitute' => 'substitution', 'compose' => 'composition'.  Also
    renamed the enumerated value Cat.E_TDM:restrict to
    Cat.E_TDM:restriction.  Also added 2 new complementary functions
    sys.Core.Relation.(is_not_member|cmpl_restriction), and added
    sys.Core.Relation.universal to go with sys.Core.Relation.empty.

    * (Core.pod)  Renamed some blob|text functions: 'catenate' =>
    'catenation', 'fold_case_to_(upper|lower)' =>
    'case_folded_to_(upper|lower)', 'trim_whitespace' =>
    'whitespace_trimmed'.  Also renamed some ordered functions:
    '(|reverse_)compare' => '(|reverse_)comparison'.

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

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

    * New file versions are: MuldisD.pm 0.12.0 and Basics.pod 0.10.1 and
    Core.pod 0.10.0.  The other pre-existing versioned files are unchanged.

    * (Core.pod)  Added new core functions Ordered.is_(in|out)side_range,
    which provide generic range checking for any Ordered subtype.

    * (Core.pod)  Renamed the 2 functions (Blob|Text).contains each to
    .is_substr, and renamed Relation.contains to .is_subset; also added 3
    new functions that are 'is_not' variants of the first 3.

    * (Core.pod)  Added new enumerated type Cat.E_RM (rounding
    method), and then merged the 5 old specialized functions
    Rat.round_(half_up|to_(even|floor|ceiling|zero)) into the 1 new generic
    function Rat.Int_from_Rat, whose second parameter is of the new type;
    also renamed Rat.rebase to Rat.round.

    * (Core.pod)  Added new ternary tuple type Cat.RatRoundRule which
    defines a controlled coercion of a real number into a rational number
    having a specific radix and precision.  (Also added new type
    Int.PInt2_N, an integer > 1, which supports it.)  Then refactored the 4
    functions Rat.(round|log|natural_(power|log)) to have 1 parameter of
    the new tuple type rather than 3 round-guiding parameters.

    * (Basics.pod, Core.pod)  Small typo fixes.

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

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

    * New file versions are: MuldisD.pm 0.11.0 and Basics.pod 0.10.0.  The
    other pre-existing versioned files are unchanged.

    * (Basics.pod)  Updated multiple sections to indicate express support
    for multi-threading within Muldis D virtual machines, where the
    transaction trees of the in-DBMS processes are mutually autonomous, but
    synchronized by the DBMS when they use the same depots.  Updated
    sections were mainly ENVIRONMENT, and TRANSACTIONS AND CONCURRENCY, and
    RESOURCE MODULARITY AND PERSISTENCE, and ENTITY NAMES.  The top level
    entity namespace 'fed' is now specifically the depot mounts by a single
    in-DBMS process, not all depot mounts in the whole DBMS.

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

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

    * New file versions are: MuldisD.pm 0.10.0 and Core.pod 0.9.2 and
    Basics.pod 0.9.0 and Grammar.pod 0.7.1 and PerlHosted.pod 0.4.1.  The
    other pre-existing versioned files are unchanged.

    * (MuldisD.pm)  Updated the DESCRIPTION to mention Muldis D in
    retrospect having some designs in common with FoxPro or xBase.

    * (Basics.pod)  Added a TERMINOLOGY item for "universal" to specify
    that Muldis D does not allow sets to be members of themselves, and more
    generally that no type or value definitions may be recursive; so
    "universal" is only the common superset of sets that these rules allow;
    some philosophers may say that it is possible for sets to have
    themselves as members, so this update specifies that Muldis D does not.

    * (Basics.pod)  Updated the 'main' routine kind to specify that it can
    not see or update any global variables, which now leaves
    '(|inner_)procedure' as the only kind that can; also that 'main' should
    just be loading/invoking depots, where all other user-defined code is.

    * (Basics.pod)  Added new RESOURCE MODULARITY AND PERSISTENCE main
    section.  Removed the whole concept of user-defined entities being
    allowed to exist outside of depots; now all user-defined entities must
    exist in depots.  Also, the conceptual role of depots has been expanded
    to cover general user code libraries, and are not mainly just for data.
    Also, all user-defined relvars|types|invokable-routines now live in
    packages, rather than users having the choice for them to be in or out;
    but package members can also be public, so no actual choice is lost.

    * (Basics.pod)  Updated ENTITY NAMES; removed the 'app' top namespace.

    * (Basics.pod)  Updated ENTITY NAMES to add the 'imp' top level
    namespace, which is like 'sys' in purpose but that while 'sys' is just
    for types and routines that are defined by the standard Muldis D
    specification, 'imp' is for other, non-standard types and routines that
    a Muldis D implementation has added, and which are specific to that
    implementation.  Also added is the new relcon namespace 'cat.impl',
    which is to 'imp' what 'cat.system' is to 'sys'.  It is expected that
    the catalog relvars under cat.(mount|foreign|interp), whose structures
    were already expected to be implementation-specific, would likely need
    to be defined in terms of (typically named nonscalar) data types that
    are also implementation-specific, and so those are invokable under
    'imp'.  Besides that main intended purpose of 'imp', a Muldis D
    implementation that wants to embrace and extend Muldis D with further
    types and routines intended for user data, should declare them there.

    * (Basics.pod, Grammar.pod, PerlHosted.pod)  Updated ENTITY NAMES, and
    other references, to rename the 'glo' (global) top-level entity
    namespace to 'fed' (federation), for better accuracy; likewise, renamed
    the 'sch' (schema) top-level namespace to 'sdp' (subdepot).

    * (Basics.pod)  Fleshed out ENTITY NAMES with new documentation
    subsections that describe the various name spaces, and interpretation.

    * (Core.pod)  Added comment to Relation.Set mentioning that a set type
    is essentially the power set of the type of its 'value' attribute.

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

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

    * New file versions are: MuldisD.pm and Core.pod 0.9.1.  The other
    pre-existing versioned files are unchanged.

    * (Core.pod)  Each main type declaration now had its own level-2
    heading rather than it being a bullet-list item.

    * Fleshed out the tail of this Changes file with a summary pre-release
    (rel. 2007 June) history of Muldis D; going from mid-2002 to mid-2007.

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

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

    * New file versions are: MuldisD.pm and Core.pod 0.9.0 and Basics.pod
    0.8.0 and Grammar.pod 0.7.0 and PerlHosted.pod 0.4.0.  The other
    pre-existing versioned files are unchanged.

    * (MuldisD.pm, Grammar.pod, PerlHosted.pod)  Added a paragraph to the
    DESCRIPTION of MuldisD.pm that gives the fully-qualified name of the
    official/original (not embraced and extended) Muldis D language spec
    that this distro represents, and gives instructions for people to
    change at least its authority portion of the name if they release their
    own modifications to the language spec, and instructs for Muldis D code
    to embed the long name of the spec they are written to.  In Grammar.pod
    and PerlHosted.pod, updated their formats for specifying the language
    long name they conform to; in both cases, the root token or PHMD node
    is now a simple sequence of these 4 parts: 'MuldisD', the authority
    string, the version number, and the payload; PerlHosted.pod also gives
    an alternative 3 parts version for up-front VM config, rather than
    repeating it with every payload later.

    * (Basics.pod)  Overhauled what kinds of Muldis D routines there are,
    and consequences thereof; the largest updates were to the ROUTINES
    section.  A hierarchical diagram was added to ROUTINES to group the
    kinds by similarity.  The 3 kinds function|update_operator|procedure
    gained inner_\w+ counterparts, which are the same but soley live within
    and comprise the definitions of other routines, while the initial 3 are
    now strictly not so.  All kinds of constraint routines are now pure
    deterministic functions (that don't see globals), like just the
    type_constraint used to be, which is fine since entire databases are
    defined as being types or variables (so now only procedure|main can see
    globals).  The distinct state_constraint is now gone, merged into
    type_constraint, each of which is tied to a data type definition and
    runs at value selection time.  Now, a transition_constraint is tied to
    a variable and runs when it is updated, it has 2 arguments holding the
    before|after state.  Updated ENTITY NAMES to split the 'lex' namespace
    into itself and 'inn', the latter being used to invoke inner routines,
    and the former being just for true lexicals.  Also updated TRANSACTIONS
    AND CONCURRENCY.

    * (Basics.pod, Core.pod)  In Core.pod, added a new SYSTEM-DEFINED CORE
    PROCEDURES section, and its first 2 entries,
    sys.Core.Control.(fail|try_catch), the use of which is now how you
    generally do explicit transactions; appropriate parts of Basics.pod
    were updated to mention/explain this.

    * (Core.pod)  Renamed the operator sys.Core.Relation.not to
    sys.Core.Relation.negation, for better symmetry with other set ops.

    * (Basics.pod)  Updated the TYPE SYSTEM section to add a new main type
    category called "remnant types", which is composed of all types that
    don't qualify as a type of the previous 5 categories.  Generally
    speaking, a remnant type is the declared type of each attribute of a
    quasi-nonscalar type, when said attribute isn't one of the special
    system-defined maximal types.  Also added the concepts of "exclusion"
    types and "negation" types to complement the 3 existing concepts of
    union|intersection|difference types.

    * (Core.pod, Grammar.pod, PerlHosted.pod)  Renamed the catalog data
    types 'Cat.ShortName' and 'Cat.LongName' to 'Cat.Name' and
    'Cat.NameChain' respectively, and updated their definitions; a Cat.Name
    must now be a non-empty string, Cat.NameChain parts must be likewise,
    and updated the escaping rules for the latter.  In Core.pod, updated
    their documentation, and added 2 more types 'Cat.NESeqOfName' and
    'Cat.FlattenedNameChain' which now are part of the definition of
    'Cat.NameChain'.  In Grammar.pod, updated the grammar concerning entity
    names so they are treated differently than text data; also added
    examples of both to EXAMPLES.  In PerlHosted.pod, added for the first
    time definitions of Cat.Name and Cat.NameChain PHMD nodes, as the new
    section CATALOG SCALAR VALUES; also, "type name" portions of older PHMD
    nodes now can take both payload formats of Cat.NameChain nodes.  Also
    in Core.pod, renamed any other types having 'ShortName' to remove the
    'Short'.

    * (Core.pod)  Added new catalog data type Cat.Type plus new supporting
    types: Cat.E_TK, Cat.E_TDM, Cat.NameTypeMap, Cat.SetOfSetOfName,
    Cat.SetOfNameChain.

    * (Core.pod)  Added new data type 'Cat.Exception' which holds the
    details of a thrown exception, but it lacks a description for now.

    * (Basics.pod)  Removed the CATALOGS main section, and the "Temp Old
    Entity Names Docs" subsection of ENTITY NAMES; these texts were very
    out of date and will be replaced later.

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-adic 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-adic 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
        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 dyadic 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.

2006-09-15 thru 2007-06-02

    * Started rewriting Rosetta again, but with a name change, since
    "Rosetta" was no longer appropriate for various reasons.  This rewrite
    took the intentionally bad and temporary name QDRDBMS, to be renamed
    again (to Muldis DB) later on.  With the name change allowed for the
    previous version numbering of Rosetta to be dropped, and this rewrite
    would eventually be first released as version zero.

    * QDRDBMS was started in the wake of having had a lot more experience
    in reading up on the truly relational model of data, and was now
    designed fundamentally to be the design and implementation of a new
    turing complete programming language for working with relational
    databases, now called "QDRDBMS D".

    * Made an experimental CPAN release of QDRDBMS version 0.0.0 on
    2007-05-31, which specifically was a quick branch that stripped out all
    the code and just contained the documentation.  This was the only CPAN
    release of the (partial) project under the QDRDBMS name.

    * Shortly after this, QDRDBMS was renamed to its presumably final name
    of "Muldis DB", and its command language to "Muldis D".  But while
    "Muldis D" stuck, "Muldis DB" was fated for a further rename later.

2006-04-14 thru 2006-11-22

    * Started a complementary Perl 6 project named "Relation" which was
    intended to provide native tuple and relation data types for ordinary
    use in Perl 6 programs like other built-in collection types.  It is
    now stagnant; it will likely get un-stuck after Muldis Rosetta sets an
    example for it.

2006-02-01 thru 2006-04-13

    * The first simultaneous releases of the Perl 5 and 6 versions of
    Rosetta's rewrite occurred on 2006-02-01; they were also the first CPAN
    releases of either version.  The Perl 6 one was Pugs release 6.2.11
    (SVN rev 8934).

    * On 2006-02-23 was the first (Perl 5) CPAN release of Rosetta where
    the project was then officially an implementation of "The Third
    Manifesto", the central work of Darwen and Date's DBMS proposal;
    moreover, Rosetta's command language was named "Rosetta D", to be a "D"
    language by the terms of said proposal.

    * On 2006-03-20 was the (Perl 5) release that declared Rosetta was to
    be fundamentally a self-contained relational DBMS (and the core
    distribution would bundle such an implementation of its API) rather
    than "just" a DBMS wrapper; though extensions could still chose to
    operate as wrappers over other DBMSs.

    * On 2006-04-13 was the last CPAN release of the Perl 5 Rosetta, and
    Pugs 6.2.12 (SVN rev 10930), on 2006-06-26, had the corresponding Perl
    6 version; Pugs 6.2.13 (SVN rev 11402), on 2006-10-27, had the last
    CPAN release of Perl 6 Rosetta, with trivial Perl 6 only updates.
    After this, Pugs would have a Muldis Rosetta instead.

2005-12-06 thru 2006-01-31

    * Rosetta started to evolve so that its API and design was based on
    relational algebra, which is a lot of smaller generic constructs that
    can easily be arranged into queries; this is in contrast to the
    previous design based around monolithic and unwieldy SQL "select"
    queries.  Generally speaking, there was increasing influence on the
    design by Hugh Darwen's and Chris Date's proposals on how a truly
    relational DBMS should work.  This time period also saw very little
    code, and almost entirely documentation updates.

2005-12-05

    * Darren Duncan is introduced by David Wheeler to the truly relational
    model of data, in a posting on the Bricolage development list in the
    "Re: [6977] New branch for maintenance of Bricolage 1.10.x." thread.

    * David said that Darren's expressed thought, that compound data types
    in table fields was a violation of first normal form, was in fact a
    misconception about the relational model.  David then referenced a
    recent interview with C. J. Date.

    * This set off a chain of events which was the largest paradigm shift
    to ever affect the Rosetta project.  While the continuing goal of
    Rosetta remained largely the same, the way this was to be accomplished
    would become quite different, and the project would gain a new goal, to
    help improve the design of relational DBMSs themselves.

2005-09-30 thru 2005-12-04

    * Started a full rewrite of Rosetta, with the intent of avoiding being
    over-engineered, and cutting corners in the short term so to get
    something useable at all sooner.  The idea was to focus on vertical
    development first, so that at least a subset of features work earlier,
    taking the development strategy of Perl6-Pugs itself as an example;
    this is in contrast to the more horizontal development strategy of the
    first Rosetta implementation.

    * Moreover, this rewrite was being done simultaneously in both Perl 5
    and Perl 6; each language had its own independent but synchronized
    version, with the Perl 6 one intended to be the main future one that
    guided design decisions, and the Perl 5 one intended to be the one
    production-ready first, to be used until Perl 6 itself was production
    ready.  That co-development was maintained afterwards, and happens with
    the Muldis Rosetta core.

2002-11-12 thru 2005-09-28, plus 2006-01-13

    * Developed and released on CPAN the Rosetta DBMS framework, whose
    intended purpose was to provide rigorous portability of database
    schemas and database-using applications between different SQL DBMS
    products.  A lot of design documentation was produced, as well as some
    code and tests, but while a significant amount of executing code was
    produced, no solution emerged that was actually useable for real work;
    what did get produced was also unnecessarily complicated.

    * The very first CPAN release of anything related to Rosetta was on
    2003-01-05, in the form of DBIx::Portable version 0.01, as
    DBIx-Portable-0.01.tar.gz.

    * A Lightning Talk was also given introducing Rosetta at OSCON 2005;
    but it is Muldis Rosetta instead that will fulfill the promises made in
    it.

2002-06-07

    * Started writing self-contained code components that were explicitly
    designed to enable external code that used them to work seamlessly on
    multiple database products.  Some of this work was reused later in the
    Rosetta DBMS framework et al, and hence 2002 is the start of the
    declared copyright date range for Muldis D language specification.
