Muldis::D Changes --------------------------------------------------------------------------- 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 "" 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'". * (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 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". * (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.