Muldis::D
Changes
---------------------------------------------------------------------------
2015-01-22
* Muldis::D version 0.200 is released on CPAN as
Muldis-D-0.200.tar.gz.
* The main purpose of this release is to clean up and refresh the main
documentation following the rough file reorganization of release
0.148.2, to reflect the Muldis-D distribution's new status of
temporarily containing two Muldis D spec versions, 0.200+ and
0.148.2, where the former is a replacing rewrite of the latter.
* Split lib/Muldis/D.pm into itself and new file
lib/Muldis/D/Outdated.pod where the latter now has the top-level
directory of the other Outdated/* files that used to be in the PREFACE
section of the former, and the former now just links to the latter.
Also updated the README file to no longer list the few dozen
lib/Muldis/D/Outdated/* files in DOCUMENTATION READING ORDER, instead
referring readers to Outdated.pod for a list.
* (D.pm) Rewrote about a third of the VERSIONING pod section and also
updated the DESCRIPTION section. The Muldis D language spec is now
formally about "Muldis D Plain Text" and not just "Muldis D"; as such,
its fully-qualified language name also now has more parts. Muldis D
language names now have 5 parts usually: Family Name, Syntax Name,
Script Name, Authority, Version Number, in that order. That is what
code files declare. This being said, the Muldis D language spec name
excludes the Script Name part as it is effectively a wildcard there.
* (D.pm,SeeAlso.pod,README,Basics.pod) Replaced any refs in this distro
to the obsolete Muldis Rosetta with its replacement Muldis::D::RefEng.
Muldis::D::RefEng is still under development and has no CPAN release
yet, which will be the case until it has a certain mainimum level of
functionality; meanwhile, what has been written can be seen on GitHub.
* (SeeAlso.pod) Update, add, or remove some entries, particularly with
regards to the Muldis D Reference Engine.
* Updated the README file to indicate that this distribution now only
has 1 public Git repository, on GitHub.com; the older one on
utsl.gen.nz appears to have been retired.
* There were also a few other minor documentation changes in the files.
* Incremented all copyright year range-ends to 2015, except for the
lib/Muldis/D/Outdated/* files, which will remain at 2011 indefinitely.
2015-01-22
* Muldis::D version 0.148.2 is released on CPAN as
Muldis-D-0.148.2.tar.gz.
* The sole purpose of this release is to rename the currently published
Muldis D spec into Muldis::D::Outdated::* so to clearly illustrate its
status, and also to make room in the old namespace for a newer
rewritten Muldis D spec to follow that takes into account the large
design changes I conceived since the middle of 2011 but didn't formally
publish, and which now are largely being implementation-driven. It is
expected that for the near future the Muldis-D distributions will have
both the newer spec versions 0.2xx.y plus the portions of the older
spec 0.148.2 which have not yet been replaced in the newer spec.
2015-01-21
* Muldis::D version 0.148.1 is released on CPAN as
Muldis-D-0.148.1.tar.gz.
* The sole purpose of this release is to publish on CPAN the various
minor updates made to the Muldis::D files since release 0.148.0, but
that any rewrites to Basics.pod's "Low Level Type System" documentation
section (made between 2013-04-08 and 2015-01-17) were reverted.
* Split the TODO file into itself and the new TODO_DRAFT file, where
the former is concise and minimal while the latter has 99% of what the
old TODO file had. The TODO_DRAFT file is only available in the Muldis
D spec version control repository, and it is not in the published
distributions on CPAN. This change alone has reduced the uncompressed
size of the distributed TODO file by 86.1KB relative to release 0.148.0
(leaving 2.7KB) and also prevented the addition of over 150KB of
additional TODO bulk. The TODO had evolved to have a lot of changeable
brainstorming and was bulking up at a rapid rate, with a lower
signal-to-noise ratio, and this seemed inappropriate to have on CPAN.
(This change committed 2011-06-07.)
* (PTMD_STD.pod) Added warning note about that the "Perl 6 grammar"
used to define the Muldis D syntax is outdated with the latest Perl 6.
(This change committed 2012-01-29.)
* (Types.pod) Updated any references to the Unicode
standard to specify version 6.2.0 rather than 6.0.0; this new 6.2.0 was
published on 2012.11.16.
(This change committed 2012-03-02 for 6.1.0, 2013-04-08 for 6.2.0.)
* (Basics.pod, Ordered.pod, Array.pod, Set.pod, Types_Catalog.pod,
Routines_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Following
the example set by Perl 6 a month earlier, renamed the Order singletons
{Increase,Decrease} to {Less,More} respectively; this was a rough
update and more related changes need doing.
(This change committed 2013-12-07.)
* (Basics.pod) Added note to "NOTES ON TEXT CHARACTER LITERALS"
documentation section about how the Unicode character "JOIN" doesn't
display properly under Mozilla applications on Mac OS X 10.9.2 but does
display properly under all other tried applications.
(This change committed 2014-04-30.)
* There were also a few other minor documentation changes in the files.
2011-05-18
* Muldis::D version 0.148.0 is released on CPAN as
Muldis-D-0.148.0.tar.gz.
* (Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Change the
"if x then y else z" / "x ?? y !! z" expressions and statement to be a
simple ternary rather than an N-ary. This results in a
backwards-incompatible simplification of both the system catalog and
the 2 Perl STD dialects; but code written in the PTMD_STD syntax has no
changes at all, since the N-ary form of the latter just had the form of
connected ternaries like "... else if ..." / "!! ... ??" anyway. In
Types_Catalog.pod, removed the 2 catalog types "IfThenExpr[|Stmt]Map"
and updated each of the 2 catalog types "IfElse[Expr|Stmt]NodeSet" to
replace its 1 "if_then" attribute with the 2 "if","then" attributes.
For all 3 STDs, updated the 2 pod sub-sections "Generic If-Else
[Expression|Statement]s" so that an if-else expression or statement now
has exactly 3, or 2-3, respectively, "expr" or "stmt" payload nodes,
rather than a list of node-pair elements plus a node element. In
contrast to if-else, no changes were made to given-when-default.
* (PTMD_STD.pod) Updated the concrete syntax for numeric or blob
literals, those with an explicit radix specifier, to use "#" rather
than ";"; for example, the "0xAF" alternative "F;AF" is now "F#AF".
This is inspired by Ada's "based" literals. More Ada formats to come.
* (PTMD_STD.pod) Updated the concrete syntax for relation literals
having separate relation heading and body blocks so that this pair is
separated by a ":" rather than a ";"; for example, "@:[x,y];{[3,4]}" is
now "@:[x,y]:{[3,4]}" where both mean "@:{{x=>3,y=>4}}".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Scalar.pod) Updated the
concrete syntax for generic scalar literals plus the "scalar
projection" postcircumfix ops to use ":" rather than ";" to separate
the possrep name from the attributes.
* (PTMD_STD.pod) Added new main pod section "LANGUAGE MNEMONICS" that
outlines PTMD_STD's syntax patterns; it has the initial complement of 8
small sub-sections: "Bareword Strings", "Quoted Strings", "#",
"{$,%,@}", "Bracketing Characters", "List-Separating Characters",
"::=", "Pairs".
2011-04-12
* Muldis::D version 0.147.0 is released on CPAN as
Muldis-D-0.147.0.tar.gz.
* This release consists of just one particularly significant change,
which is to redefine a recipe (and hence an updater) as being a special
case of a procedure rather than being a disjoint kind of routine; but
this is mainly just a system catalog and grammar consolidation; there
is no change to the syntax of the language. Between this release and
release 0.146.0, all kinds of imperative routines are consolidated into
procedure, so now all routines are just functions xor procedures.
Additionally, the general case of a procedure can now directly
reference/update globals/"the database" and it can now directly contain
arbitrarily complex value expressions plus arbitrary multi-update
statements and pseudo-variable definitions and it is no longer
necessary to farm out to functions or recipes for most common
procedural work, and so coding Muldis D should be more like what
programmers expect from typical other languages and SQL, without the
needless seemingly arbitrary constraints and associated complexity.
This 3-way consolidation brings a very considerable streamlining to
Muldis D; between release 0.145.0 and 0.147.0, the total size of the
language spec proper (all 34 files in lib/) has decreased by 34.3KB or
2.8%; this without losing any functionality, and in fact gaining some.
* (Basics.pod) Under the main pod section "ROUTINES", renamed the pod
sub-section "Functions, Recipes, and Procedures" to "Functions and
Procedures", and made substantial updates to that sub-section so that
"recipe" is no longer a distinct one of 3 main routine kinds; rather
there are now just the 2 "function" and "procedure", and "recipe" is
now considered a special case of "procedure", and the general case of
a procedure can now do directly everything that a recipe can.
* (Types_Catalog.pod) Redefined the catalog type "Recipe" (and hence
"Updater") as being a proper subtype of "Transaction" (and hence
"Procedure") rather than a disjoint type. Removed the catalog type
"RecipeSet" (use "ProcedureSet" instead). Updated the catalog type
"Package" to remove its "recipes" attribute of that type. Merged the
definition/attributes of the old "Recipe" catalog type into the
"Procedure" type; of the 12 substantial attrs that "Procedure" now has,
only "Recipe" had the 3 ["[upd|ro]_global_params", "exprs"], only
"Procedure" had the 3 attrs ["is_system_service", "is_transaction",
"vars"], and both had the 5 attrs ["[upd|ro|opt|dispatch]_params",
"implements"], and both had a "stmt" attr but Recipe's was a
"MultiUpdStmt" and Procedure's was and is a "StmtNodeSet". Renamed the
catalog type "ImpInvoStmtNodeSet" to "ProcInvoStmtNodeSet" (and updated
"StmtNodeSet" to rename its attribute of that type), renamed its
"imperative" attr to "procedure", retyped its 2 attrs "[upd|ro]_args"
from "IISArgVarMap" (that type was then removed) to "NameExprMap".
Replaced the catalog type "MultiUpdStmt" partially with the new catalog
type "MultiUpdStmtNodeSet", and "ProcInvoStmtNodeSet" takes care of the
remaining part; updated "StmtNodeSet" to add a "multi_upd_stmts" attr
of the new type. Removed the 3 catalog types
"[SysScaVal|NilFuncInvo|APMaterialNCSel]StmtNodeSet" (use
"[SysScaVal|FuncInvo|APMaterialNCSel]ExprNodeSet" in concert with
"ProcInvoStmtNodeSet" instead); updated "StmtNodeSet" to remove its
3 attrs of those types. Renamed the catalog types
"[If|When]ThenVarStmtMap" to "[If|When]ThenExprStmtMap", and
"RcpGlobalVarAliasMap" to "ProcGlobalVarAliasMap", and
"[A|R]PImperativeNC" to "[A|R]PProcedureNC".
* (Routines_Catalog.pod) Removed the catalog routine "rcp_invo" (use
"proc_invo" instead). Removed the 2 catalog routines
"[create|drop]_recipe" (use "[create|drop]_procedure" instead).
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) For all 3 STDs, consolidated
the grammar specific to recipes into the grammar specific to
procedures. A "recipe" grammar node is now just a "procedure" node
with additional constraints. The "Recipe Specification" pod
sub-section is now merged into "Procedure Specification". The "GENERIC
RECIPE STATEMENTS" pod main section is now merged into "GENERIC
PROCEDURE STATEMENTS". The 2 pod sub-sections "Generic
In-[Multi-Update-Statement|Procedure] Imperative Invocation Statements"
were merged into the 1 "Generic Procedure Invocation Statements"; in
just PTMD_STD, the latter also had a portion of "Generic Function
Invocation Expressions" moved into it; in just the 2 Perl STDs, where
there used to be 2 statement node kinds "i[mus|proc]-imp-invo", there
is now the 1 "proc-invo". Replaced the "Procedure Atomic Statements"
pod sub-section with "Multi-Update Statements", which takes over the
same syntax (but that, in just the 2 Perl STDs, the statement node kind
"atomic-stmt" was replaced with "multi-upd-stmt") and maintains its
semantics while compiling it differently into the catalog, as procedure
multi-update statements rather than as nested recipe definitions; the
code example for this sub-section was also replaced, so it shows
multiple insert statements into different relvars rather than a pair of
generic assignments, because the latter can now more easily be written
without using the multi-update statement syntax this section describes.
Removed the pod sub-section "Procedure Value Expressions" and with it
the 3 main node kinds ["proc_expr", "var_name", "nil_func_invo"] (use
["expr", "expr_name", "func_invo"] instead). The "IMPERATIVE
INVOCATION ALTERNATE SYNTAX STATEMENTS" main pod section is now renamed
to "PROCEDURE INVOCATION ALTERNATE SYNTAX STATEMENTS"; its 2 pod
sub-sections "Imperative Simple [Monadic Post|Non-symmetric Dyadic
In]fix Operators" were renamed to substitute "Procedure".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) For all 3 STDs, added a code
example to "Procedure Simple Non-symmetric Dyadic Infix Operators" that
demonstrates the use of pseudo-tuple-variables in a single ":="
statement to swap the values of two variables.
* (PTMD_STD.pod) In the main pod section "RESOLVING AMBIGUITY",
created new sub-section "Entity Names vs Keywords" for its existing
content, and added new sub-section "Statements vs Expressions" with new
content. Also, in "NESTING PRECEDENCE RULES", tweaked "Logical Infix".
2011-03-12
* Muldis::D version 0.146.0 is released on CPAN as
Muldis-D-0.146.0.tar.gz.
* This release is a snapshot in the process of streamlining Muldis D.
It consists of just one change, which is to redefine an updater as
being a special case of a recipe rather than being a disjoint kind of
routine; but this is mainly just a system catalog and grammar
consolidation; there is no change to the syntax of the language.
* (Basics.pod) Under the main pod section "ROUTINES", renamed the pod
sub-section "Functions, Updaters, Recipes, and Procedures" to remove
the "Updaters, ", and made substantial updates to that sub-section so
that "updater" is no longer a distinct one of 4 main routine kinds;
rather there are now just the 3 ["function", "recipe", "procedure"],
and "updater" is now considered a special case of "recipe".
* (Types_Catalog.pod) Redefined the catalog type "Updater" as being a
proper subtype of "Recipe" rather than a disjoint type. Removed the
catalog type "UpdaterSet" (use "RecipeSet" instead). Updated the
catalog type "Package" to remove its "updaters" attribute of that type.
* (Routines_Catalog.pod) Removed the catalog routine "upd_invo" (use
"rcp_invo" instead). Removed the 2 catalog routines
"[create|drop]_updater" (use "[create|drop]_recipe" instead).
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) For all 3 STD, consolidated
the grammar specific to updaters into the grammar specific to recipes.
An "updater" grammar node is now just a "recipe" node with additional
constraints. The "Updater Specification" pod sub-section is now merged
into "Recipe Specification". Th "GENERIC UPDATER OR RECIPE STATEMENTS"
main pod section is now renamed to "GENERIC RECIPE STATEMENTS".
2011-03-10
* Muldis::D version 0.145.0 is released on CPAN as
Muldis-D-0.145.0.tar.gz.
* This release mostly consists of a few smaller changes done around
2010-11-13 (subsequent bullets 1-3), 2011-01-17 (subsequent bullet 4),
and 2011-02-20 (subsequent bullet 5). They are being put out now as a
catch-up release, and then numerous large/significant releases should
follow soon after.
* (Basics.pod) Split the "TRANSACTIONS AND CONCURRENCY" main pod
section into the 4 pod sub-sections "ACID", "Virtual Machine",
"Transactions and YYY", "Concurrency".
* (Basics.pod) Rewrote the few scattered paragraphs that mentioned
concurrency models or MVCC or locking or isolation or whatever, this
gathered into said new "Concurrency" sub-section that officially
declares that Muldis D is now agnostic to concurrency models and may be
used with either locking or MVCC or other options.
* (PTMD_STD.pod) Added comment that PTMD_STD has "linear syntax".
* (Basics.pod) Added comment mentioning SQL/MED, federated databases.
* (SeeAlso.pod) Under the "INFORMATION SOURCES" main pod section,
added the 2010 July book "Database Explorations: Essays on The Third
Manifesto and Related Topics" to the list, and updated the few urls to
online copies of TTM chapters so they resolve to the latest versions
published in this book. Also noted that this is the very first time
that Muldis D or its author or related projects have ever been
recognized in an actual printed-on-paper book.
* Incremented all copyright year range-ends to 2011.
2010-11-12
* Muldis::D version 0.144.0 is released on CPAN as
Muldis-D-0.144.0.tar.gz.
* (Basics.pod, Types_Catalog.pod, Types.pod) Updated the official type
system details concerning types having no values, aka "Empty" and its
aliases, so that it is now officially allowed to use an empty type
anywhere that otherwise any type at all may be used. This serves both
to simplify things a bit and also to remove some places where the spec
logically contradicts itself. It also is serves to bring Muldis D back
into compliance with an aspect of TTM that is now better explained in
the latter's newest version. "Empty" may now be used as the declared
type of an attribute of a tuple or of a scalar possrep, and not just of
a relation; such a tuple or scalar type then has zero values since no
tuple or scalar value can exist that doesn't have a value for an
attribute; such a relation type still has exactly 1 value as before,
the value with an existing heading and an empty body. Users may now
officially declare types with no values. The catalog types for
defining types no longer find it unconditionally mandatory to specify a
default value. The sources list of a domain-type may now be empty;
this is now the official way to declare the "Universal" and "Empty"
types themselves, which is as a nullary-domain-[intersection|union]
respectively. The "Core" module no longer declares Universal|Empty in
its "special_types"; now only Int|List are declared there, which works
out better as they are the only declaration/non-enumeration types.
The default "DomainType" value now declares "Empty", not "Universal".
* (Types.pod) Updated the Text.Unicode type description to correct and
expand what it says about the UTF-8 encoding.
* (Temporal.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In
Temporal.pod, renamed the virtual system-service "fetch_curr_instant"
to "fetch_trans_instant" and updated its description to specify that
all invocations of it within the same parent-most transaction would
fetch the exact same value, which is the instant when said transaction
was started. The semantics of the routine weren't previously described
with this much accuracy, so it would have been ambiguous as to whether
that was meant or whether "current" meant when the routine was invoked.
In all 3 STD.pod, updated any code examples to account for the rename.
* (PTMD_STD.pod, HDMD_Perl5_STD.pod, Basics.pod, Types.pod, Cast.pod)
For PTMD_STD and HDMD_Perl5_STD, updated the formats of numeric and
blob literals, and of character escape sequences that spell Unicode
codepoints. To be specific, the 4 [bodx] formats for the common bases
2,8,10,16 have been altered so that they now take the form "0MNNN"
rather than "M;NNN". Also relaxed all of the same literal formats so
that alpha characters A..F or A..Z may now alternately be written in
lowercase and not just in uppercase; but the [bodx] character itself is
still restricted to lowercase. These changes combined make the "0xNNN"
numeric formats identical to their Perl 6 counterparts, and likewise
typically nearly identical to Perl 5 and other common languages which
have the counterparts. This also makes the other formats much closer
to being counterpart identical. Updated PTMD_STD Int example:
"0o5703"; Blob example: "0b'110010010'"; Text example: "'\c<0x2A1D>'".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Corrected the code examples
for stimulus-response-rule to say "nlx.lib.main" rather than "main".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In PTMD_STD, updated the
"::=" name-binding syntax for routine expressions and statements to add
the optional keyword "let"; so "foo ::= 3" may now alternately be
spelled "let foo ::= 3"; this may make code easier to read. In both
Perl-STD, added "let" as an alternative for "::=" as the first element
of a "named_expr" or "named_stmt" grammar node.
2010-10-20
* Muldis::D version 0.143.0 is released on CPAN as
Muldis-D-0.143.0.tar.gz.
* This release is another snapshot in the process of overhauling
matters of character strings.
* (Types_Catalog.pod) In a partial reversal of one aspect of release
0.140.0, further to that started in release 0.141.0, updated the
catalog data type "Comment" to once again compose the
"Ordered" and "Stringy" mixins.
* (Types_Catalog.pod, Types.pod) Removed the 2 catalog types
"[U|C]CPString" and the types which used them now use "[|O]String"
instead. But these or similar types may be brought back later.
* (Types.pod, Types_Catalog.pod) Updated any references to the Unicode
standard to specify version 6.0.0 rather than 5.2.0; this new 6.0.0 was
published on 2010.10.11 but some parts are still being proofread.
* (Types.pod, Types_Catalog.pod) Reorganized the text types again, now
arriving at something fundamentally a lot more like the state of
release 0.139.0. Renamed the mixin type "Text" to "Textual". Split
the scalar root type "Text.Unicode" into itself plus "Text" and
"Text.Unicode.Canon". Now "Text" is the scalar root type which
composes "Textual" and "Ordered", and it has an infinite character
repertoire and a "String"-typed possrep attribute. Now "Text.Unicode"
is a subtype of "Text" which adds codepoint plus utf8-octet possreps
(the latter is new), and is a not-normalized string of Unicode
codepoints. Now "Text.Unicode.Canon" is a subtype of "Text.Unicode"
and is NFD; it is the closest thing to what the "Text" of 0.139.0 or
the "Text.Unicode" of 0.142.0 were. Also added new subtype
"Text.Unicode.Compat" of "Canon" which is NFKD. The 2 types
"Text.ASCII" and "Text.Latin1" remain as subtypes of "Unicode" which
each add a possrep. Also moved "CoreText" into Types_Catalog.pod and
updated it to exclude the 33 ASCII control characters so now it just
has the 95 printable and space characters; it is now also a "Text"
subtype. Also removed the "SysText" domain-union type, and "Text" is
now used as the possrep attribute of "Name" and "Comment".
* (Types_Catalog.pod) Updated the "Name" and "Comment" catalog types
to explicitly compose the "Textual" mixin type rather than "Stringy".
2010-10-16
* Muldis::D version 0.142.0 is released on CPAN as
Muldis-D-0.142.0.tar.gz.
* This release is another snapshot in the process of externalizing the
complexities of character strings, particularly those brought on by the
likes of Unicode, from the core. A larger one will follow soon.
* (Basics.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)
Simplified the low-level type system such that "String" values are now
internally repertoire-agnostic, and they now rely on an external
context for the interpretation of their elements. A "String" is now
primarily a "List" of 2 elements rather than 3; the middle "element
repertoire" element has been removed. In Basics.pod, updated the "Low
Level Type System" pod sub-section with a new description for "String".
In Types_Catalog.pod, updated the descriptions of the 4 "String" proper
subtypes. In all 3 STD.pod, updated the "List" literal code examples.
* (Types.pod, Types_Catalog.pod, Basics.pod) Renamed the 3 core types
"Minimal_Text", "MCPString", "Unicode_Text to "CoreText", "CCPString",
"Text.Unicode" respectively.
Also redefined the "CoreText" type to match ASCII rather than Base64.
* (Types_Catalog.pod) Updated the "Package" catalog type to add a
constraint that all of the "Name" and "Comment" typed components of a
"Package" value, respectively, must all have text of th same text type.
* (Types.pod) Added new type "Text.ASCII" which is a proper
subtype of "Text.Unicode" and so the two are comparable, while
"CoreText", whose repertoire Text.ASCII shares, isn't comparable. So
users should default to using ASCII over Core when former is supported.
* (Types.pod) Added new type "Text.Latin1" which is a proper
subtype of "Text.Unicode" as per "Text.ASCII".
* (PTMD_STD.pod) In a partial reversal of one aspect of release
0.49.0, updated the PTMD_STD grammar for all comma-separated lists so
that a trailing comma after the last list item of a nonempty list is
now permitted but optional. This brings syntax parity with one aspect
of the Perl language and should make it easier to edit Muldis D code.
2010-10-12
* Muldis::D version 0.141.0 is released on CPAN as
Muldis-D-0.141.0.tar.gz.
* This release is a snapshot in the process of externalizing the
complexities of character strings, particularly those brought on by the
likes of Unicode, from the language core. More will follow soon.
* (Types_Catalog.pod, Routines_Catalog.pod, Basics.pod, Types.pod) In
a partial reversal of one aspect of release 0.140.0, brought back the
catalog data type "Comment" and changed the declared types of all
"scm_comment" attributes or parameters back to "Comment" (or
"just_of.Comment"). However, the restored "Comment" type does not
compose the "Ordered","Stringy" mixins as the old one did, and there is
still no as-value literal syntax for it in the STD dialects.
* (Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod) Renamed 3
catalog types as follows: "SysCatSet" -> "CatalogSet", "OVLScalar" ->
"SysScalar", "SysScaVal[Expr|Stmt]NodeSet" ->
"OVLScaVal[Expr|Stmt]NodeSet"; also updated each of the 2 catalog types
"[Expr|Stmt]NodeSet" to rename 1 of its attrs from "ovl_*" to "sys_*".
* (Types.pod, Types_Catalog.pod) Split the core scalar type "Text"
into itself plus the 2 new "Unicode_Text" and "SysText" such that
"Unicode_Text" is identical to the old "Text" but for the name and the
new "Text" is now a mixin type that "Unicode_Text" composes (instead of
"Stringy", which is now implicit as the new "Text" composes "Stringy")
and "SysText" is now a domain type that unions initially just
"Unicode_Text". "Text" and "Unicode_Text" are declared in Types.pod
and "SysText" in Types_Catalog.pod. Also updated each of the catalog
types "Name" and "Comment" so that its possrep attribute is now
"SysText"-typed rather than "Text"-typed.
* (Types.pod, Types_Catalog.pod, Basics.pod) Added the 2 new core
scalar types "Minimal_Text" (which composes the "Text" mixin) and
"MCPString", the first in Types.pod and the second in
Types_Catalog.pod. "Minimal_Text" is a proprietary repertoire that
corresponds directly to that of "base64url", having 64 characters,
intended to be the only core text type, whose main purpose is for
writing source code identifiers (names of types and routines etc) in,
including all the core system-defined ones.
2010-10-08
* Muldis::D version 0.140.0 is released on CPAN as
Muldis-D-0.140.0.tar.gz.
* This release features a consolidation of the system catalog and
associated revised conceptions of Muldis D's language structure, such
that all the system defined materials plus all non-special
system-defined namespaces are now organized in the same way as
user-defined materials, which is into "packages"; a "depot" is a pure
Muldis D package loaded by the DBMS in user space while a "module" is a
typically mixed-language package loaded by the DBMS readonly in system
space. So "Core" and each official or unofficial Muldis D language
extension is now a named module and it is now normal for all entities
within each such system module to reference each other in the "nlx"
relative path namespace rather than "sys", and so "sys" is now more
like "fed", mainly just used to reference entities outside the
referencer's own package using an absolute path. This also means it is
now more or less official that one can define a system package using
exactly the same Muldis D dialects/syntaxes as to define user packages.
(This release didn't actually tweak the dialects themselves, but that
could be done later, and they're still correct as is regarding depots.)
* (Basics.pod) In the "NOTES ON TERMINOLOGY" main pod section, added
definitions of the 2 terms "module" and "package". In the "ENTITY
NAMES" main pod section, updated the namespace hierarchy diagram to
simplify the "sys" portion and clarify the "nlx" portion. Also split
the "User-Defined Entities" sub-section into itself and "Non-Lexical
Entities" and updated those plus various other "ENTITY NAMES"
sub-sections plus a few other bits in the file.
* (Types_Catalog.pod) Renamed the main POD section "TYPES FOR DEFINING
DEPOTS AND SUBDEPOTS" to substitute "PACKAGE" for each "DEPOT". Split
the catalog type "Depot" into itself plus the 2 new "Package" and
"Module" such that "Package" is initially identical to the old "Depot"
but for the name and the new "Depot" plus "Module" are defined as
initially non-proper subtypes of "Package". Renamed but otherwise
initially left unchanged the 3 catalog types "SubdepotSet",
"SysSpecTypeSet", "SysNspSet" to "SubpackageSet", "SpecialTypeSet,
"SpecialNspSet" respectively. Renamed the "Package" attribute
"subdepots" to "subpackages" and the "System" catalog type attribute
"namespaces" to "special_namespaces". Then added new catalog type
"ModuleSet" and updated the "System" type to add a new "modules"
attribute of that type; the new type/attribute is structured like the
many other types/attributes of "System" that embed materials but that
they instead embed "Module". Then eliminated the 14 catalog types
"Sys[Function|Updater|Recipe|Procedure]Set",
"Sys[Scalar|Tuple|Relation|Domain|Subset|Mixin]TypeSet",
"Sys[|Distrib][Key|Subset]ConstrSet" and updated the "System" catalog
type to eliminate its 14 attributes of those same types, since the 1
new "modules" attribute and all the corresponding types that are used
for defining "Depot" attributes can now be used as is for all
system-defined namespaces and materials that are defined in the catalog
as a user material would be defined. Also updated the description of
the "System" attribute "special_namespaces" to reflect that it no
longer defines most namespaces, such as "Core" or "Core.Type" etc,
since "materials" now takes over that role more elegantly, and now
"special_namespaces" just declares the 15 special ones like "sys.std".
Then moved the "special_types" attribute from "System" to "Package" and
updated the "Depot" subtype to require that attribute be empty. Also
the "Module" subtype was updated to require the "Package" attributes
"stim_resp_rules", "data" to be empty, but those may be relaxed later.
Updated a few other related bits of documentation in the file.
* (Basics.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)
Muldis D no longer has the core concept of a "transition constraint",
which was an assertion on whether a variable is allowed (according to
current business rules) to transition directly from one state to
another. So the routine kind "transition-constraint", its associated
syntaxes, and the catalog data type "TransConstrFunc" were all removed.
The rationale for this change is that transition constraints would be
better off as a user-definable concept (that could also be provided as
a Muldis D language extension) which is defined instead as a "state
constraint" associated with a database schema that explicitly stores
multiple versions of data in an auditing fashion, such as
"temporal/historical databases" do. These matters may be arbitrarily
complex and seem best suited to be user-definable rather than in core.
At the very least, the previous "transition constraint" concept was
flawed in significant ways, such as that: 1. It couldn't take any other
states into account other than the immediately last and next one, where
in real life what is a valid transition can depend on multiple prior
states; 2. When what looks like multiple successive distinct
transactions to one user would look like a single larger transaction to
another user due to how the MVCC or serializability etc works, what are
the consistent semantics for a constraint saying a status must go
A->B->C and not A->C?; 3. Reverting certain user mistakes could require
circumventing / temporarily disabling a direction-enforcing constraint.
* (Universal.pod, Basics.pod, Types.pod, Types_Catalog.pod,
Boolean.pod, Relation.pod, Array.pod, Text.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod, Conventions.pod) Renamed the 2 functions
"is[|_not]_identical" to "is[|_not]_same"; also updated the first one's
description to focus on mutual substitutability being the key in
considering their arguments to be "same". The term "same" is better
by being a little more abstract in its meaning and should be
interpreted as any or all of ["same", "equal", "identical",
"substitutable", etc]; moreover, "same" is better by being terser and
by being more like related functions "before" and "after_or_same" etc.
* (PTMD_STD.pod) Made nonquoted DBMS entity names subject to the
"op_char_repertoire" pragma such that the old limited-to-ASCII format
of such names is now just the case when the pragma is "basic"; now when
the pragma is "extended", such names may include any characters that
Unicode considers alphabetic or alphanumeric. Also restricted both
formats of nonquoted entity names to require each hyphen to be followed
by an alphabetic character. And so, extended names are now exactly the
same as Perl 6 identifiers except for not also allowing apostrophes.
* (Types_Catalog.pod, Routines_Catalog.pod, Basics.pod, Types.pod,
PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In Types_Catalog.pod, eliminated
the catalog data type "Comment" and changed the declared types of all
"scm_comment" attributes to "Text" (or "just_of.Text"). In
Routines_Catalog.pod, likewise changed the declared types of all
"scm_comment" parameters. In all 3 STD, eliminated the as-value
"Comment" value literal syntax; now just PTMD_STD has the more typical
"non value comment" syntax, and that syntax is unchanged from before.
In all files, updated any other refs to aforementioned as appropriate.
* (D.pod, SeeAlso.pod) Now spell author personal names
as "Edgar Codd (E.F. Codd)" and "Chris Date (C.J. Date)" rather than
as "Edgar F. Codd" and "Christopher J. Date", respectively.
2010-09-03
* Muldis::D version 0.139.0 is released on CPAN as
Muldis-D-0.139.0.tar.gz.
* (HDMD_Perl[6|5]_STD.pod) Updated all routine invocation alternate
syntax expressions so that the first node element is no longer just
"op" but rather is one of the 3 ["i-op", "pre-op", "post-op"] depending
on whether it represents infix, prefix, or postfix syntax. Besides
making the Perl-STD code better self-documenting, this also means that
we now have 3 separate namespaces for the operators, and so for example
we can now have "!" as both prefix and postfix without confusion.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Integer.pod, Boolean.pod)
Renamed the special postfix syntax for the factorial op from "i!" to
"!", which then looks exactly like it does in maths.
* (PTMD_STD.pod) Updated all the simple monadic postfix operators that
are symbolic (++,--,!) so that whitespace between each operator and its
argument is now optional. So, for examples, you can now say "13++" or
"4--" or "5!" and not "5 !"/etc. This is a stopgap pending better ws.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Numeric.pod, Basics.pod)
Renamed the special prefix syntax for the absolute-value op from "||"
to "abs", as people would incorrectly think "or" on seeing the old one
while it doesn't look enough like "|x|",
and most languages use "abs" already. However, "|-|" is still used for
the absolute-difference op, which has no precedent, looks like "|a-b|".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Prefixed a few pod section
headings and added notices that: The "rtn_inv_alt_syn" catalog
abstraction level as it currently exists is deprecated and will
disappear in the near future. Other pending enhancements to the
language in both the system catalog itself and in the "plain_rtn_inv"
level will make the latter more capable and suitable by itself for
normal use. A new highest level or 3 will probably appear in place of
"rtn_inv_alt_syn" later for their still-unique useful features.
2010-08-09
* Muldis::D version 0.138.0 is released on CPAN as
Muldis-D-0.138.0.tar.gz.
* (PTMD_STD.pod) Updated the PTMD_STD grammar root token to explicitly
state that it may have optional leading or trailing whitespace (such as
blank or comment lines), but nothing else leading or trailing; this is
something that was only implied by convention before.
* (PTMD_STD.pod) Mostly rewrote the "NESTING PRECEDENCE RULES" main
pod section so that it now has 10 precedence levels rather than 7, and
so the operator precedences should now be more user-friendly. This
rewrite is strongly influenced by the Perl 6 operator precedence table,
and also by the Postgres operator precedence table. This rewrite is
mainly about format, and partially about content. The 2 tightest
(terms, postfix) and 2 loosest (shorting infix, binding infix) levels
are unchanged from the original 7. The 3 middle levels (prefix, dyadic
infix, reducing infix) were reorganized into 5 different middle levels
(generic prefix, generic infix, comparison, logical prefix, logical
infix). Just one new, loosest, level (assignment) is not from the
original 7. The misguided concept of all dyadic infix (eg, -, /)
having tighter precedence than all N-adic infix (eg, +, *) was
eliminated, with these 2 levels now being merged into a single level;
this single level was then divided into 3 levels, with all logical ops
having the lowest precedence, then all comparison ops higher, and all
remaining ops such as maths higher. The single logical prefix op,
'not', now has lower prec than the math/compare ops rather than higher.
In the future, the generic and logical infix levels will need splitting
so they conform better to people's expectations, but meanwhile, making
them all the same is an improvement over the old dyadic/N-adic thing.
* (D.pm) Added declaration that Muldis D is an "Acmeist" language.
2010-07-24
* Muldis::D version 0.137.0 is released on CPAN as
Muldis-D-0.137.0.tar.gz.
* This release features a cleanup/consolidation of the operators for
testing the membership of values in collections, or of tuples in
relations, and a simplification of the basic order-comparison ops.
* (PTMD_STD.pod, Interval.pod) Remove the "between" aliases for the
interval membership test infix ops; now just the "in" spellings remain.
* (Ordered.pod, Interval.pod) Updated each of the 11 functions
"is_[before|after][|_or_same]", "min", "max", "minmax",
"Interval.[has|value_is]_[|not_]member" to remove its optional "func"
parameter; so now each of the 11 just has 2 or N mandatory inputs, and
the declared type of those is now "Ordered" rather than "Universal".
These 11 functions now unconditionally wrap the virtual
"sys.std.Core.Ordered.order" function rather than wrapping an
order-determination function given as an argument (or said virtual by
default). This change results in a simplification for 99% of likely
use cases; for the remaining 1% which the 11 funcs have dropped support
for, users can write their own equivalents of the 11 easily enough.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the grammar and
examples of the infix special syntax of the above 11 functions to
reflect their just being plain dyadic or commutative infix ops without
optional parts now. Reorganized so that the 11 are no longer in the
separate "Order Comparison Operators" pod sub-section but rather are in
the "Simple Commutative N-adic Infix Reduction Operators" or "Simple
Non-symmetric Dyadic Infix Operators" pod sub-sections as appropriate.
The "Order..." section now just has the 1 op "<=>" for "Ordered.order".
* (PTMD_STD.pod, Relation.pod) Renamed all 10 variants of all 4 dyadic
infix operators for testing the membership of a generic tuple in a
generic relation. With the 4 Unicode variants, replaced any "r" with
"@"; with the 6 ASCII variants, renamed any "*in-r" to "*inside" and
any "r-*has" to "*holds". For examples, "Relation.has_member" is now
spelled "holds" or "@∋" rather than "r-has" or "r∋", and
"tuple_is_member" is "inside" or "∈@", not "in-r" or "∈r".
* (Types.pod) Added new mixin type "Collective" that is intended to be
explicitly composed by other types that are effectively simple
homogeneous collections of values, and something more specific than
relations in general. Also updated the 5 types "Set", "Array",
"Bag", "[S|M]PInterval" to compose "Collective".
* Added new initially empty file lib/Muldis/D/Core/Collective.pod
which will hold virtual routines for types composing the "Collective"
type. Also updated the README file, Core.pod to mention the new file.
* (Set.pod, Array.pod, Bag.pod, Interval.pod, PTMD_STD.pod) In each of
the 3 files [Set.pod, Bag.pod, Interval.pod], for each of the 4
functions "[has|value_is]_[|not_]member", renamed its primary parameter
to "coll" from "set|bag|interval". In Array.pod, for each of the 2
funcs "has_[|not_]elem", renamed its primary to "coll" from "topic".
* (Collective.pod, Set.pod, Bag.pod, Interval.pod) In Collective.pod,
added the 4 new virtual functions "[has|value_is]_[|not_]member". Then
in each of [Set.pod, Bag.pod, Interval.pod], updated the 4 same-named
functions so that they explicitly implement the same-named new
virtuals; also consolidated the updated routines.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Collective.pod, Set.pod,
Bag.pod, Interval.pod) For each of the 4 functions
"[has|value_is]_[|not_]member", merged the triples of
set|bag|interval-specific spellings of its dyadic infix syntax into a
single spelling that works for all 3 types; the dyadic infix syntax
will now invoke the 4 virtual funcs rather than their 12 implementers.
For example, we used to have "in-s","in-b","in-i" and now
we have "in"; or, we used to have "s∌","b∌","i∌" and now we have "∌".
* (Interval.pod) For each of the 4 functions
"[has|value_is]_[|not_]member", renamed it into an additional level of
namespace, "SP"; for example "sys.std.Core.Interval.SP.has_member".
Then added 4 new funcs that are the same as the first 4 but that they
work on "MPInterval" rather than "SPInterval", live in "MP" namespace.
* (Array.pod) Added the 2 new functions "value_is_[|not_]elem" which
are aliases for the 2 existing "has_[|not_]elem". Then updated all 4
so that they implement the 4 virtual "Collective" functions having the
same names but for "elem" vs "member"; also consolidated the 4 funcs.
* (PTMD_STD.pod) Updated the semantics of parsing string literals
having literal non-SPACE whitespace chars so that they are more
flexible or DWIMmy. Previously, said chars were simply stripped, and
now they plus adjoining runs of spaces are now replaced with a single
space, or if escaped ws precedes said literal ws, then the ws+space
runs are just stripped instead. The new behaviour should make the
selected string values invariant with both the code's linebreak chars
and with the code's indenting style, while saving useful formatting.
* (PTMD_STD.pod) Updated all the simple monadic prefix operators that
are symbolic (all but 'not') so that whitespace between each operator
and its argument is now optional. So, for examples, you can now say
"!is_foo" or "#people" or "%relvar" and not have to be "# people"/etc.
This change is a stopgap measure and later a more generic solution
should be found for making whitespace optional around operators.
2010-07-17
* Muldis::D version 0.136.0 is released on CPAN as
Muldis-D-0.136.0.tar.gz.
* This release features improvements to the handling of comments and
whitespace, and the addition of bag function syntaxes.
* (PTMD_STD.pod) The grammar now considers whitespace to be anything
matched by "\s", meaning Perl's/Unicode's concept of it, rather than it
just being composed of the 5 characters [\ \t\n\f\r].
* (PTMD_STD.pod) Changed how whitespace in delimited string literals
is handled. Previously, non-SPACE whitespace was disallowed from
appearing literally in strings except as a "splitter" token, where it
was delimited by a backslash pair which told the parser to ignore/strip
said whitespace. Now, any characters are allowed literally in strings
and all non-SPACE whitespace is automatically ignored/stripped by the
parser. To actually select such whitespace as part of the string, it
now has to be encoded as an escape sequence such as "\n". And so, now
it is easier to write block-size strings or comments as one no longer
needs some kind of delim per each line, not even a backslash/splitter.
* (PTMD_STD.pod, Basics.pod) Reformatted non-value-comment literals so
that they are now delimited by both backticks and number signs, the
former nested in the latter, rather than just number signs; for example
" #`This is a non-value comment.`# "; the as-value-comment literals
have not changed; for example " `This is an as-value comment.` ". The
first consequence of this is that the standalone number sign can now be
more easily freed up to be used for things other than comments,
including by itself as an operator. The second consequence of this is
that all comments are now delimited by backticks, rather than some just
by backticks and others just by num signs. Also more comments changes.
* (PTMD_STD.pod) Updated the grammar to explicitly include support for
embedding non-value comments anywhere that whitespace may appear that
is outside of a scalar value lit; the "<ws>" token now includes them.
Previously, the non-value comments were defined but not actually
invoked anywhere by the main grammar. Details subject to be refined.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Relation.pod) Renamed the
prefix operator for set/relation cardinality to "#" from "r#".
* (PTMD_STD.pod, Bag.pod) Added function invocation alternate syntax
expressions for 13 "Bag" functions. For the 12 of these that have the
same unqualified names as "Relation" (Set) funcs, the former use the
latter's alternate syntax but with a "+" suffix. These 12 are
"cardinality" (#+), "union" (∪+), "intersection" (∩+), "diff" (∖+) and
the 8 sub/superset operators. The 13th Bag func is "union_sum" (∪++).
The existing ops aren't overloaded because Bag isa subtype of Relation.
2010-07-16
* Muldis::D version 0.135.0 is released on CPAN as
Muldis-D-0.135.0.tar.gz.
* This release features a cleanup/consolidation of the postcircumfix
operator syntaxes, and a renaming of the sub/superset infix ops.
* (Types.pod) Added new mixin type "Attributive" that is intended to
be explicitly composed by other types that are considered to be
collections of named attributes, such as generic tuples and relations.
Also updated the 2 types "Tuple", "Relation" to compose "Attributive".
* Added new initially empty file lib/Muldis/D/Core/Attributive.pod
which will hold virtual routines for types composing the "Attributive"
type. Also updated the README file, Core.pod to mention the new file.
* (Attributive.pod, Tuple.pod, Relation.pod) In Attributive.pod, added
the 8 new virtual functions ["degree", "is_[|not_]nullary",
"has_attrs", "attr_names", "rename", "projection", "cmpl_proj",
"static_exten", "[|cmpl_|un]wrap"] and 4 new virtual updaters
["assign_rename", "assign_static_exten", "assign_projection",
"assign_cmpl_proj"]. Then in each of Tuple.pod and Relation.pod,
updated the 12 same-named routines so that they explicitly implement
the same-named new virtuals; also consolidated the updated routines.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Attributive.pod, Tuple.pod,
Relation.pod) For each of the 6 functions ["rename", "projection",
"cmpl_proj", "[|cmpl_|un]wrap"], merged the pair of
tuple|relation-specific formats of its postcircumfix syntax into a
single format that works for both types; the postcircumfix syntax will
now invoke the 6 virtual functions rather than their 12 implementers.
For example, we used to have "%{%<-}","@{%<-}" and we now have "{%<-}".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Scalar.pod, Tuple.pod,
Relation.pod, Set.pod) Renamed all remaining postcircumfix op variants
that had a [$,%,@] sigil preceding the opening curly brace so to remove
that sigil. All "${...}" were renamed to "{;...}", the ".{}" (Just)
was renamed to ".{*}", and any other renames simply removed the sigils.
* (PTMD_STD.pod, Relation.pod) Renamed the ASCII variants of all 8
dyadic infix subset/superset operators so that they now are symbolic in
appearance rather than alphabetic. For examples, "⊆" is now mapped to
"{<=}", not "sub", and "⊅" is now mapped to "{!>}", not "!psuper".
* (PTMD_STD.pod) Fix a fossil from v0.130.0 re "x" -> "~#" in grammar.
2010-07-13
* Muldis::D version 0.134.0 is released on CPAN as
Muldis-D-0.134.0.tar.gz.
* (PTMD_STD.pod, HDMD_Perl[5|6]_STD.pod, Basics.pod, Types_Catalog.pod)
For PTMD_STD and HDMD_Perl5_STD, updated the formats of numeric and
blob literals, and of character escape sequences that spell Unicode
codepoints, so that it is easier to write numbers in a radix other than
10. Still unchanged is that you can write numbers either in a general
form of "M;NNN" for bases 2..35 or in just base-10 as "NNN". Now, the
general form adds aliases for the common bases of 2,8,10,16 such that
the "M" may alternately be spelled "b","o","d","x". For bases 2,8,16
this new form is now the recommended one. PTMD_STD Int example:
"o;5703"; Blob example: "b;'110010010'"; Text example: "'\c<x;2A1D>'".
* (HDMD_Perl6_STD.pod) Updated the code examples for Int and Rat
literals using bases 2,8,16 to use Perl 6's 0bN,0oN,0xN numeric formats
rather than its :M<N> format.
* (HDMD_Perl5_STD.pod) Updated the code examples for Int literals
using bases 2,8,16 to use Perl 5's 0bN,0N,0xN numeric formats rather
than Perl5-STD's single-elem-hash-ref format. The code examples for
Rat literals had no corresponding update as Perl 5 doesn't support it.
* (HDMD_Perl6_STD.pod) Now that the Perl 6 spec (S02) finally (as of a
2010.07.12 update) says what a Perl 6 Blob literal looks like
(":2{NNN}", ":8{NNN}", ":16{NNN}"), updated the Perl6-STD example code
denoting Perl 6 Blob lits to that from temp stand-in "Blob.new(...)".
2010-07-09
* Muldis::D version 0.133.0 is released on CPAN as
Muldis-D-0.133.0.tar.gz.
* This release features some concrete syntax additions to make Muldis D
code easier to write, to be more terse while still readable.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) For all 3 STD, updated the
formats of generic scalar or tuple or relation value literals so that
they may be written more tersely. Now, one may substitute "$","%","@"
respectively for "Scalar","Tuple","Relation" as the "value_kind"
leading part of a "value" node. That is, for example, in PTMD_STD,
the 3 ["Scalar:MyType:{...}", "Tuple:{...}", "Relation:{...}"] may now
alternately be spelled ["$:MyType:{...}", "%:{...}", "@:{...}"].
* (PTMD_STD.pod) For just PTMD_STD, updated the formats specific to
set, array, bag, and interval value literals so that they may be
written more tersely. Now, one may omit the "value_kind" leading part
of a "value" node when writing most of these. For examples:
a Set: "{25,43,6}"; an Array: "['here','there','everywhere']";
a Bag: "{'Plum' => 200, 'Cherry' => 100, 'Apricot' => 300}";
an SPInterval: "{21..30}"; an MPInterval: "{-Inf..3,14,266..Inf}".
2010-07-07
* Muldis::D version 0.132.0 is released on CPAN as
Muldis-D-0.132.0.tar.gz.
* This release features some reworking of char escape sequences. The
prior way of doing this could give the false impression that PTMD_STD
couldn't be single-pass parsed; the new way should avoid that problem,
and also result in string literals that are easier for people to read.
* (PTMD_STD.pod) A backslash pair used inside a long string/etc
literal, to support splitting the literal over multiple code lines, now
surrounds mandatory whitespace rather than optional whitespace. In the
grammar, this pair is now called a "splitter" rather than an "unspace".
(Another backslash pair, outside strings/etc, is still an "unspace".)
* (PTMD_STD.pod) Removed the simple char escape seq for "space" char,
which had limited utility; instead of "\s", one can say "\c<F;20>".
* (PTMD_STD.pod) Updated any of the simple char escape sequences that
differed from those of typical other languages so that they are the
same instead. The escape sequences for the 5 characters [\,',",`,#]
are now simply the same characters with a leading backslash, instead of
a backslash+alpha; they used to be [\b,\a,\q,\g,\h]. A consequence
is that a string may now contain the same literal char as is used to
delimit that string, like typ langs, where this used to be disallowed.
2010-06-23
* Muldis::D version 0.131.0 is released on CPAN as
Muldis-D-0.131.0.tar.gz.
* (PTMD_STD) Fixed semantic-reversing typo.
* (Types.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod,
Basics.pod, Relation.pod, Set.pod) Renamed the nonscalar types
"Single","DHSingle" to "Just","DHJust" and the corresponding type name
prefix from "single_of." to "just_of." and the corresponding concrete
syntax value literal kind from "Single" to "Just". So now the triple
of related types/values "Maybe","Just","Nothing" match the names of
their counterparts in the Haskell language. So now the canonical
syntax for selecting a Maybe value is either "Just:{foo}" or "Nothing".
In Set.pod, renamed the "single" function to "just", and updated the
"order" function to rename 3 of its parameters from "S" to "J".
2010-06-20
* Muldis::D version 0.130.0 is released on CPAN as
Muldis-D-0.130.0.tar.gz.
* This release features multiple concrete syntax changes. The largest
change is the elimination of the "$" sigil that was used
semi-gratuitously to mark data-entities (variables, parameters,
attributes, named expression nodes). These are now regularly formatted
as barewords instead, like most languages and SQL, but unlike Perl.
Likewise eliminated the "|" sigil for named statement nodes. Another
significant change is the renaming or elimination of all language
keywords that had consisted of just a single latin character, meaning
that users can define any single-letter entity names without ambiguity.
Also renamed a syntax shorthand from ">foo" to "=>foo" for clarity.
* (D.pm, README) Updated the list of email forums focusing on
Muldis D and its implementations, first to add a 4th list
muldis-d-language, and second to update all 4 lists' descriptions.
* (Text.pod) Renamed function "accents_stripped" to "marks_stripped".
* (SeeAlso.pod) Updated a few external reference urls.
* (Array.pod, Bag.pod, Blob.pod, Boolean.pod, Cast.pod, Integer.pod,
Interval.pod, Numeric.pod, Ordered.pod, Rational.pod, Relation.pod,
Routines_Catalog.pod, STDIO.pod, Scalar.pod, Set.pod, Stringy.pod,
Text.pod, Tuple.pod, Universal.pod, Counted.pod, Temporal.pod) Updated
all system-defined routine documentation so that the illustrative
declarations of each now just have the unqualified routine names, same
as the real declarations would, rather than being fully-qualified; the
level-2 heading for each routine description already has the latter.
In Routines_Catalog.pod, also upd th 2 named constraint descs likewise.
* (PTMD_STD.pod) Updated the shorthand syntax for "foo=>foo" that
looked like ">foo" to instead look like "=>foo"; people kept confusing
the old format for the greater-than op; the new should be more obvious.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Universal.pod, Set.pod)
Removed 2 func invo alt syn exprs: "d" (prefix), "//d" (infix).
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Stringy.pod, Cast.pod)
Renamed 3 func invo alt syn exprs: "x" -> "~#" (infix),
"t" -> "%" (prefix), "r" -> "@" (prefix).
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Set.pod) Removed the func
invo alt syn expr "s" (prefix) and updated any code examples using it
from "s foo" to "Maybe:{foo}". Converted the func invo alt syn expr
"v" (Maybe.attr) from prefix format to postcircumfix format; using it
now looks like "foo.{}" (empty curly quote pair) rather than "v foo".
* (PTMD_STD.pod) Added new main pod section "RESOLVING AMBIGUITY"
which talks about language keywords versus user-defined entities.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Basics.pod) Eliminated the
"|" sigil from statement names, which are now always sigil-less (and
typically barewords) instead. In PTMD_STD, a "stmt_name" grammar token
is now just a "Name_payload". In the 2 Perl-STD, the first elem of the
"stmt_name" node kind is now "s" rather than "|" (so in Perl 6 this is
usually a Pair); for "named_stmt" it is now "::=" rather than "|::=".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Basics.pod) Eliminated the
"$" sigil from data-entity names, which are now always sigil-less (and
typically barewords) instead. In PTMD_STD, a "lex_entity_name" grammar
token is now just a "Name_payload". In the 2 Perl-STD, the first elem
of the "expr_name" and "var_name" node kinds are now "d" rather than
"$" (so in Perl 6 this is usually a Pair); for an "accessor" node it is
now "acc" rather than "$.".
* (Array.pod, Bag.pod, Blob.pod, Boolean.pod, Cast.pod, Integer.pod,
Interval.pod, Numeric.pod, Ordered.pod, Rational.pod, Relation.pod,
Routines_Catalog.pod, STDIO.pod, Scalar.pod, Set.pod, Stringy.pod,
Text.pod, Tuple.pod, Universal.pod, Counted.pod, Temporal.pod) Updated
all system-defined routine documentation as per the prior change item,
so the illustrative routine signatures no longer use the "$" sigils.
2010-05-17
* Muldis::D version 0.129.1 is released on CPAN as
Muldis-D-0.129.1.tar.gz.
* (D.pm, README, Makefile.PL) Updated any instances of
"http://mm.DarrenDuncan.net/mailman/listinfo" so that they are fully
lower-cased, because the mixed case version doesn't work with some web
browsers; browsers that don't automatically convert it to lowercase get
a "There currently are no publically-advertised mailman lists" message.
* Purged this distribution's "Changes" file of practically all change
details for its approximately 147 releases numbered 0.0.0 thru 0.129.0,
most of those now just constituting a single bullet-point in total. If
you want to see those change descriptions, look either in the version
control system as of tag "release-0.129.0" or in the archived
distribution tarball named Muldis-D-0.129.0.tar.gz.
* This is the Muldis-D-0.129.1 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/Array.pod
lib/Muldis/D/Core/Bag.pod
lib/Muldis/D/Core/Blob.pod
lib/Muldis/D/Core/Boolean.pod
lib/Muldis/D/Core/Cast.pod
lib/Muldis/D/Core/Integer.pod
lib/Muldis/D/Core/Interval.pod
lib/Muldis/D/Core/Numeric.pod
lib/Muldis/D/Core/Ordered.pod
lib/Muldis/D/Core/Rational.pod
lib/Muldis/D/Core/Relation.pod
lib/Muldis/D/Core/Routines_Catalog.pod
lib/Muldis/D/Core/Scalar.pod
lib/Muldis/D/Core/Set.pod
lib/Muldis/D/Core/STDIO.pod
lib/Muldis/D/Core/Stringy.pod
lib/Muldis/D/Core/Text.pod
lib/Muldis/D/Core/Tuple.pod
lib/Muldis/D/Core/Types.pod
lib/Muldis/D/Core/Types_Catalog.pod
lib/Muldis/D/Core/Universal.pod
lib/Muldis/D/Dialect/HDMD_Perl5_STD.pod
lib/Muldis/D/Dialect/HDMD_Perl6_STD.pod
lib/Muldis/D/Dialect/PTMD_STD.pod
lib/Muldis/D/Ext/Counted.pod
lib/Muldis/D/Ext/Spatial.pod
lib/Muldis/D/Ext/Temporal.pod
lib/Muldis/D/SeeAlso.pod
LICENSE/GPL
Makefile.PL
MANIFEST
MANIFEST.SKIP
README
t/Muldis_D_00_Compile.t
TODO
2008-04-07 thru 2010-05-16
* 2010-05-16 : Muldis::D version 0.129.0.
* 2010-05-10 : Muldis::D version 0.128.0.
* 2010-05-08 : Muldis::D version 0.127.0.
* 2010-05-07 : Muldis::D version 0.126.0.
* 2010-05-05 : Muldis::D version 0.125.0.
* 2010-05-01 : Muldis::D version 0.124.0.
* 2010-04-27 : Muldis::D version 0.123.0.
* 2010-04-25 : Muldis::D version 0.122.0.
* 2010-04-24 : Muldis::D version 0.121.0.
* 2010-04-23 : Muldis::D version 0.120.0.
* 2010-04-19 : Muldis::D version 0.119.0.
* 2010-04-17 : Muldis::D version 0.118.0.
* 2010-04-11 : Muldis::D version 0.117.0.
* 2010-04-07 : Muldis::D version 0.116.0.
* 2010-04-02 : Muldis::D version 0.115.0.
* 2010-03-27 : Muldis::D version 0.114.0.
* 2010-03-13 : Muldis::D version 0.113.0.
* 2010-03-10 : Muldis::D version 0.112.0.
* 2010-03-05 : Muldis::D version 0.111.0.
* 2010-03-01 : Muldis::D version 0.110.0.
* 2010-01-26 : Muldis::D version 0.109.0.
* 2010-01-24 : Muldis::D version 0.108.0.
* 2010-01-16 : Muldis::D version 0.107.0.
* 2010-01-07 : Muldis::D version 0.106.0.
* 2010-01-03 : Muldis::D version 0.105.0.
* 2009-12-26 : Muldis::D version 0.104.0.
* 2009-12-20 : Muldis::D version 0.103.0.
* 2009-11-30 : Muldis::D version 0.102.0.
* 2009-11-26 : Muldis::D version 0.101.0.
* 2009-11-21 : Muldis::D version 0.100.0.
* 2009-11-06 : Muldis::D version 0.99.0.
* 2009-10-20 : Muldis::D version 0.98.0.
* 2009-10-18 : Muldis::D version 0.97.0.
* 2009-10-14 : Muldis::D version 0.96.1.
* 2009-10-13 : Muldis::D version 0.96.0.
* 2009-10-08 : Muldis::D version 0.95.0.
* 2009-10-05 : Muldis::D version 0.94.0.
* 2009-09-28 : Muldis::D version 0.93.0.
* 2009-09-26 : Muldis::D version 0.92.0.
* 2009-09-21 : Muldis::D version 0.91.0.
* 2009-09-19 : Muldis::D version 0.90.0.
* 2009-09-13 : Muldis::D version 0.89.0.
* 2009-09-12 : Muldis::D version 0.88.0.
* 2009-09-03 : Muldis::D version 0.87.0.
* 2009-09-02 : Muldis::D version 0.86.0.
* 2009-08-29 : Muldis::D version 0.85.0.
* 2009-08-24 : Muldis::D version 0.84.0.
* 2009-08-20 : Muldis::D version 0.83.0.
* 2009-07-27 : Muldis::D version 0.82.0.
* 2009-07-15 : Muldis::D version 0.81.0.
* 2009-07-06 : Muldis::D version 0.80.0.
* 2009-06-16 : Muldis::D version 0.79.1.
* 2009-06-13 : Muldis::D version 0.79.0.
* 2009-06-09 : Muldis::D version 0.78.0.
* 2009-06-06 : Muldis::D version 0.77.0.
* 2009-06-04 : Muldis::D version 0.76.1.
* 2009-06-04 : Muldis::D version 0.76.0.
* 2009-05-28 : Muldis::D version 0.75.0.
* 2009-05-27 : Muldis::D version 0.74.0.
* 2009-05-19 : Muldis::D version 0.73.0.
* 2009-05-15 : Muldis::D version 0.72.0.
* 2009-05-14 : Muldis::D version 0.71.0.
* 2009-05-11 : Muldis::D version 0.70.0.
* 2009-05-08 : Muldis::D version 0.69.0.
* 2009-05-06 : Muldis::D version 0.68.0.
* 2009-05-04 : Muldis::D version 0.67.0.
* 2009-04-29 : Muldis::D version 0.66.0.
* 2009-04-28 : Muldis::D version 0.65.1.
* 2009-04-22 : Muldis::D version 0.65.0.
* 2009-04-16 : Muldis::D version 0.64.0.
* 2009-04-02 : Muldis::D version 0.63.0.
* 2009-03-20 : Muldis::D version 0.62.3.
* 2009-03-19 : Muldis::D version 0.62.2.
* 2009-03-19 : Muldis::D version 0.62.1.
* 2009-03-17 : Muldis::D version 0.62.0.
* 2009-03-13 : Muldis::D version 0.61.0.
* 2009-02-25 : Muldis::D version 0.60.0.
* 2009-02-07 : Muldis::D version 0.59.1.
* 2009-02-07 : Muldis::D version 0.59.0.
* 2009-01-19 : Muldis::D version 0.58.0.
* 2009-01-08 : Muldis::D version 0.57.0.
* 2008-12-27 : Muldis::D version 0.56.0.
* 2008-12-19 : Muldis::D version 0.55.0.
* 2008-12-16 : Muldis::D version 0.54.0.
* 2008-12-15 : Muldis::D version 0.53.0.
* 2008-11-29 : Muldis::D version 0.52.0.
* 2008-11-29 : Muldis::D version 0.51.0.
* 2008-11-08 : Muldis::D version 0.50.0.
* 2008-10-07 : Muldis::D version 0.49.0.
* 2008-09-18 : Muldis::D version 0.48.0.
* 2008-08-30 : Muldis::D version 0.47.0.
* 2008-08-17 : Muldis::D version 0.46.0.
* 2008-08-15 : Muldis::D version 0.45.0.
* 2008-08-12 : Muldis::D version 0.44.0.
* 2008-07-29 : Muldis::D version 0.43.0.
* 2008-07-21 : Muldis::D version 0.42.0.
* 2008-07-15 : Muldis::D version 0.41.0.
* 2008-07-08 : Muldis::D version 0.40.0.
* 2008-07-04 : Muldis::D version 0.39.0.
* 2008-06-30 : Muldis::D version 0.38.0.
* 2008-06-28 : Muldis::D version 0.37.0.
* 2008-06-24 : Muldis::D version 0.36.0.
* 2008-06-21 : Muldis::D version 0.35.0.
* 2008-06-13 : Muldis::D version 0.34.0.
* 2008-06-04 : Muldis::D version 0.33.0.
* 2008-06-04 : Muldis::D version 0.32.0.
* 2008-05-20 : Muldis::D version 0.31.0.
* 2008-05-12 : Muldis::D version 0.30.0.
* 2008-05-11 : Muldis::D version 0.29.0.
* 2008-05-09 : Muldis::D version 0.28.1.
* 2008-05-01 : Muldis::D version 0.28.0.
* 2008-04-27 : Muldis::D version 0.27.0.
* 2008-04-21 : Muldis::D version 0.26.0.
* 2008-04-13 : Muldis::D version 0.25.1.
* 2008-04-07 : Muldis::D version 0.25.0.
2008-03-22
* Muldis::D version 0.24.0 is released on CPAN as
Muldis-D-0.24.0.tar.gz. This was the first time that the Muldis D
language spec was in a "Muldis-D-N.N.N" distribution or that the spec's
root document had the name Muldis::D, starting here with then
version 0.24.0; these names have been used uninterrupted through the
present day.
* 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
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
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
* Language::MuldisD version 0.23.0 is released on CPAN as
Language-MuldisD-0.23.0.tar.gz. This was the last time that the Muldis
D language spec was in a "Language-MuldisD-N.N.N" distribution or that
the spec's root had the name Language::MuldisD, version 0.23.0.
2007-07-24 thru 2008-02-29
* 2008-02-29 : Language::MuldisD version 0.22.1.
* 2008-02-26 : Language::MuldisD version 0.22.0.
* 2008-02-15 : Language::MuldisD version 0.21.0.
* 2008-02-07 : Language::MuldisD version 0.20.0.
* 2008-02-07 : Language::MuldisD version 0.19.1.
* 2008-02-03 : Language::MuldisD version 0.19.0.
* 2008-01-25 : Language::MuldisD version 0.18.0.
* 2008-01-12 : Language::MuldisD version 0.17.0.
* 2008-01-05 : Language::MuldisD version 0.16.0.
* 2007-12-31 : Language::MuldisD version 0.15.0.
* 2007-12-18 : Language::MuldisD version 0.14.0.
* 2007-12-09 : Language::MuldisD version 0.13.0.
* 2007-11-23 : Language::MuldisD version 0.12.0.
* 2007-11-19 : Language::MuldisD version 0.11.0.
* 2007-11-08 : Language::MuldisD version 0.10.0.
* 2007-10-11 : Language::MuldisD version 0.9.1.
* 2007-10-09 : Language::MuldisD version 0.9.0.
* 2007-09-23 : Language::MuldisD version 0.8.1.
* 2007-09-22 : Language::MuldisD version 0.8.0.
* 2007-09-11 : Language::MuldisD version 0.7.0.
* 2007-09-03 : Language::MuldisD version 0.6.0.
* 2007-08-31 : Language::MuldisD version 0.5.0.
* 2007-08-12 : Language::MuldisD version 0.4.1.
* 2007-08-09 : Language::MuldisD version 0.4.0.
* 2007-07-24 : Language::MuldisD version 0.3.1.
2007-07-24
* Language::MuldisD version 0.3.0 was released on CPAN as
Language-MuldisD-0.3.0.tar.gz. This was the first time that the Muldis
D language spec was released as its own distribution, a practice which
had continued uninterrupted through the present day. The spec's root
document had the name Language::MuldisD, starting here with then
version 0.3.0.
* This was 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
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-06-20 thru 2007-07-20
* On 2007-06-20 was the very first CPAN release, as
Muldis-DB-0.0.0.tar.gz, of "Muldis DB for Perl 5", version 0.0.0; it
bundled the very first CPAN release of "Muldis D" the language spec,
version 0.0.0. At this time, the entire existing Muldis D language
spec was contained in the single file "Language.pod", which had the
name Muldis::DB::Language.
* 2007-06-29 : Muldis::DB::Language version 0.0.1.
* 2007-07-11 : Muldis::DB::Language version 0.1.0.
* On 2007-07-20 was the very last CPAN release, as
Muldis-DB-0.2.0.tar.gz, of "Muldis DB for Perl 5" that bundled the
Muldis D language spec, version 0.2.0. After this time the two would
be released separately, in their own namespaces.
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.