Muldis::D
---------------------------------------------------------------------------
2010-05-10 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.128.0 is released on CPAN as
Muldis-D-0.128.0.tar.gz.
* This release features the beginning of the addition of concrete
syntax for specifying data types and non-function-defined constraints
for data types. A lot of this detail is still missing, but it can be
inferred by looking at the complete abstract syntax which it would
closely resemble (more so than with routine definitions).
* (Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Completed
the change item begun in release 0.127.0 concerning
non-function-defined type constraints becoming full-fledged materials.
In Types_Catalog.pod, corrected the error with the 4 "RelationType" or
"TupleType" attributes that each should have had
"set_of.RelPathMaterialNC" as its declared type rather than
"RelPathMaterialNC". In all 3 STD.pod, updated the "MATERIAL
SPECIFICATION" main pod section to pre-declare the 4 new material node
kinds "[|distrib_][key|subset]_constr".
* (Types_Catalog.pod) Updated the catalog type "RelationType" to merge
its attribute "key_constraints" into its "constraints" attribute, which
is now simply a list of constraint-defining materials of either of the
2 kinds. Similarly updated the catalog type "TupleType" to merge its 3
attributes "distrib_key_constraints", "[|distrib_]subset_constraints"
into its "constraints" attribute, which is now simply a list of
constraint-defining materials of either of the 4 kinds.
* (Types_Catalog.pod, Routines_Catalog.pod) Updated the catalog types
"System", "Depot" to abbreviate each of their 4 attribute names
"[|distrib_][key|subset]_constraints" to
"[|distrib_][key|subset]_constrs". Also abbrev names of the 4 assoc
catalog routines to "[create|drop]_[|distrib_][key|subset]_constr".
* (Routines_Catalog.pod) Added new main pod section "SYSTEM-DEFINED
CONSTRAINT MATERIALS" with 2 initial "key-constraint" defining
materials for convenience, that are neither types nor routines, named
"sys.std.Core.Cat.nil_[key_constr|prim_key]"; kc range over zero attrs.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In all 3 STD.pod, completely
populated the pod sub-section "Key Constraint Specification", thereby
providing the complete grammar for a unique key constraint or candidate
key for a relation type, which can be a primary key, which can range
over 0..N relation attributes. Explained how the grammar mapped to the
catalog type "KeyConstr", etc. Three simple code examples are
provided, in all 3 grammars. In PTMD_STD, this section sections
introduced the new main node kind "key_constr".
* (PTMD_STD.pod) In just PTMD_STD.pod, populated just the concrete
grammar for each of the 6 pod sub-sections
"[Scalar|Tuple|Relation|Domain|Subset|Mixin] Type Specification",
thereby showing the main grammar for declaring any kind of data type,
sans some kinds of contraints or the virtual-attr-maps; omitted are the
explanations of how these grammar blocks are interpreted as
system-catalog records, and omitted are code examples. Completely
omitted are the 2 Perl-STD analogies. These grammar sections are
essentially complete, but may be subject to change. The change notes
of subsequent releases will likely pretend these grammars aren't
present yet, such that as their host sections are completed, they will
be explained as if the whole section was added at that time.
2010-05-08 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.127.0 is released on CPAN as
Muldis-D-0.127.0.tar.gz.
* This release features some significant changes to the way that
non-function-defined type constraints are declared and referenced.
Previously, these 4 kinds of constraint definitions were embedded in
relation or tuple type definitions: (unique) key constraint,
distributed (unique) key constraint, subset constraint (foreign key),
distributed subset constraint. And yet, each of these had a declared
name that was conceptually in the general materials namespace, such
that these names had to be distinct from other materials, and attribute
names. Now, these 4 constraint definition kinds have been promoted
into 4 new full-fledged material kinds, which complements the other 11
existing regular material kinds (4 routine, 6 type, 1 stimulus-response
rule). Now, instead of embedding the constraints, the relation and
tuple types now refer to them by name, same as with function-defined
type constraints, and the reality now closely matches the conception.
* (Routines_Catalog.pod) Fixed a couple related kinds of fossils from
release 0.116.0 where catalog types in Types_Catalog.pod had "comment"
attribues renamed to "scm_comment", and "scm_vis_ord" attributes added,
but any corresponding "create_\w+" recipes in Routines_Catalog.pod
weren't updated accordingly. In Routines_Catalog.pod, updated 12
recipes for "scm_comment" and 11 of those for "scm_vis_ord".
* (Routines_Catalog.pod) Added 2 new recipes
"sys.std.Core.Cat.[create|drop]_stim_resp_rule", which should have been
done as part of the prior 2 releases' addition of basic
stimulus-response rules support, but wasn't. They are analogous to SQL
[CREATE|DROP] TRIGGER statements. Also renamed the pod sub-section
"Recipes For Defining Depot Routines and Data Types" to "Recipes For
Defining Depot Materials".
* (Types_Catalog.pod) Removed the catalog type "APNonTypeNC" which is
now considered superfluous; its 2 ex-proper-subtypes now cite
"AbsPathMaterialNC" as their proper supertype instead.
* (Types_Catalog.pod) Renamed the 2 catalog types "[|Distrib]KeySet"
to "[|Distrib]KeyConstrSet". Also updated the catalog type
"RelationType" to rename its "keys" attribute to "key_constraints", and
"TupleType" to rename its "distrib_keys" attribute to
"distrib_key_constraints".
* (Types_Catalog.pod) Moved the declarations of the 3 catalog types
"[DKMemRel|DKRelAttrKey|SCChildAttrParent]AttrMap" downwards to just
after "ComposedMixinSet".
* (Types_Catalog.pod) Split each of the 4 catalog types
"[|Distrib][Key|Subset]ConstrSet" 2 ways, into itself plus the
same-name without the "Set", where the no-"Set" version is a tuple type
having all the main attributes and the "Set" version is a relation type
composing an attribute of the no-"Set" type. For each of the 4 type
pairs, both members have the 1 "scm_comment" old attribute, and only
the relation type has the 2 old "name", "scm_vis_ord" attributes. For
each of the 4 type pairs, the relation type has the 1 new "material"
attribute whose type is the tuple type. With the "KeyConstr" type
pair, only the tuple type has the 2 "attrs", "is_primary" attributes;
with "DistribKeyConstr", the 3 "attrs", "relations", "is_primary"; with
"SubsetConstr", the 4 "parent", "parent_key", "child", "attr_map"; with
"DistribSubsetConstr", the 3 "parent_distrib_key", "child", "attr_map".
* (Types_Catalog.pod) Updated each of the 4 catalog types
"[|Distrib][Key|Subset]ConstrSet" to add a "parent" 5th attribute, and
otherwise updated its documentation so that it now is completely
properly formatted like a list of materials, such as "FunctionSet" is.
Then moved the declarations of these 4 types upwards to immediately
follow the "MixinTypeSet" et al declaration, in the process also
combining them into a single multi-definition section for brevity as
they all have exactly the same 5-attribute main format. Also cloned
from those 4 catalog types the 4 additional
"Sys[Tuple|Relation]TypeSet" types. Also updated each of the 2 catalog
types "System", "Depot" to add the 4 attributes
"[|distrib_][key|subset]_constraints" having the appropriate 4 types.
Also updated the 1 "RelationType" attribute "key_constraints", plus the
3 "TupleType" attributes "distrib_key_constraints",
"[|distrib_]subset_constraints", to change each of their declared types
to "RelPathMaterialNC" (but that should have been
"set_of.RelPathMaterialNC"), as they now reference the constraints by
material invocation name rather than embedding them.
* (Routines_Catalog.pod) Added 8 new recipes
"sys.std.Core.Cat.[create|drop]_[|distrib_][key|subset]_constraint", in
correspondence to the previous change item.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In the "MATERIAL
SPECIFICATION" main pod section, added these 4 empty placeholder pod
sub-sections, which will be populated in near-future spec releases:
"[|Distributed ][Key|Subset] Constraint Specification".
2010-05-07 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.126.0 is released on CPAN as
Muldis-D-0.126.0.tar.gz.
* This release has a set of smaller changes and additions but no
concrete syntax for data type or key/etc constraint declarations; the
missing are now expected in the next release. The current release
instead addresses all of the other known high-priority TODO items that
remain, some of which are prerequisites for said concrete syntax.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Types_Catalog.pod) Completed
the change item begun in release 0.125.0 concerning basic
stimulus-response rules support. In both Perl-STD, added the new pod
sub-section "Stimulus-Response Rule Specification" under "MATERIAL
SPECIFICATION". In PTMD_STD.pod, added the missing/TODO paragraph in
that same sub-section. In Types_Catalog.pod, updated the
"StimRespRule" catalog type description to indicate its default value.
* (Basics.pod) Updated the main pod section "STIMULUS-RESPONSE RULES"
to add a couple paragraphs, one about security and controlling whether
stimulus-response rules auto-run or not, and one abrout related DBMS
command-line parameters.
* (Basics.pod) Add a paragraph to the "MULDIS D" main pod section
which explains a fundamental Muldis D quality, affecting various other
language design decisions. Muldis D is designed for the DBMS
environment where a single program may run 24x7x365 for months or years
and yet regularly self-mutate its own code while it is running to meet
changing user needs without taking the DBMS down. This is unlike other
general purpose languages that have to quit and restart the program
following an upgrade.
* (Types_Catalog.pod) Refactored the catalog types for defining scalar
types so that they are now fundamentally defined in terms of tuple
types, which define their attribute lists and basic constraints,
similarly to how relation types are defined; this change was made to
simplify the spec and grammar by cutting down on redundancy. Updated
the catalog type "PossrepSet" to replace its 2 attributes "attrs",
"constraint" with the 1 attribute "tuple_type", which names the tuple
type that defines the attributes/etc of each scalar possrep; also
updated the catalog type "PossrepMapSet" to update the description of
its "p2_from_p1" (and implicitly "p1_from_p2") so that the named
possrep-map function must now use the same tuple types as used in
"type_type" for its declared parameter and result types. A consequence
of this change item is that it is now mandatory to also explicitly
declare a tuple type over which a possrep is partly directly defined,
every time, and not just for use by a possrep-map when more than one
possrep exists for a scalar type. In support of this status quo, also
added new singleton tuple type C<sys.std.Core.Type.Cat.D0> whose sole
value is C<Tuple:D0>; use it as th tuple type for singleton scalar tps.
* (Types_Catalog.pod, Basics.pod) Refactored the catalog types that
declare or compose mixin types so that all inter-type references are
oriented in the correct direction. The declaration of a mixin type's
default value is no longer in said mixin type, but rather is in the
other type that composes said mixin type. Conceptually, a mixin type
is supposed to have zero knowledge of any other types that compose it,
with the knowledge only in the composer, and now the actuality matches
the conception. In Types_Catalog.pod, added new catalog type
"ComposedMixinSet", which defines a set of names of declared mixin data
types which are being composed by another type, and for each it
indicates whether the composing type is asserting that it will provide
the default value of the mixin type; then, for each of the 6 catalog
types "[Scalar|Tuple|Relation|Domain|Subset|Mixin]Type", changed the
declared type of its "composed_mixins" type from "set_of.RPTypeNC" to
the new type; then, updated the "MixinType" to remove its "default" 3rd
attribute. In Basics.pod, made a small mixin type description update.
2010-05-05 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.125.0 is released on CPAN as
Muldis-D-0.125.0.tar.gz.
* This release features computational and Turing completeness; the
Muldis D language spec is now complete enough, both in system-catalog
and concrete grammars, that Muldis D can simulate any computer. Muldis
D code can now be a "main program" (run automatically at system
startup), can do user I/O, can read from and write to memory, can
contain conditionals, can contain repetition, can calculate any values
from single or multiple other values, and all this using only syntax
and features that are described in the current written spec.
* (PTMD_STD.pod, STDIO.pod, Integer.pod, Rational.pod, Temporal.pod)
In PTMD_STD.pod, updated the "Procedure Specification" pod sub-section
so that a procedure body now has a pair of square brackets delimiting
it rather than a pair of curly braces. This further instills the
visual mnemonic that square brackets means that the relative order of
the elements inside them is significant, while the relative order of
elements in curly braces is not significant; as it is true for array
elements vs sets etc, it is true for proceure statements vs atomic
routines etc. As part of this update, split the grammar node
"empty_routine_body" into the 2 "empty_[atomic|procedure]_body". In
the other 4 files, updated all 10 system-service routine signatures to
use "[...]" to represent the routine body rather than "{...}".
* (Routines_Catalog.pod) Removed the procedure "sys.std.Core.Cat.noop"
since, for any purpose it might have been used, better options exist.
* (Types_Catalog.pod) Updated the "Procedure" catalog type to make it
more strict in that the root node of its "stmt" statement tree must
always be a compound statement node, not any other kind of stmt node.
As it is, the root would be a compound likely 99% of the time in real
procedures, and this restriction lets the concrete grammars be simpler.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Formalized the syntax for
compound statements in procedures, where each such statement is a
sequence of other statements that execute in order at different times,
which is the heart of what makes a procedure nonatomic. Added the new
pod sub-section "Generic Compound Statements" in the main pod section
"GENERIC PROCEDURE STATEMENTS", including a code example. In PTMD_STD,
this section introduced the main node kind "compound_stmt". In all 3
files, updated the sub-section "Procedure Specification" such that a
nonempty procedure body may now have zero explicit statements rather
than requiring one, because the body now implicitly always has a
compound statement as its root statement.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new special shorthand
syntax for inlining an updater definition plus an invocation of said in
a procedure statement, as a concept called a "procedure atomic
statement". Added th new pod sub-section "Procedure Atomic Statements"
in the main pod section "GENERIC PROCEDURE STATEMENTS", including a
code example. In PTMD_STD, this section introduced the main node kind
"atomic_stmt", which looks similar to a "compound_stmt" but for having
curly brace delimiters rather than square brackets, and for appearing
as an updater body than as a procedure body. In all 3 files, updated
code example in the sub-section "Procedure Specification" to make use
of the new shorthand syntax for its inner updater rather than a "with".
* (Types_Catalog.pod) In a reversal of one aspect of release 0.29.0,
brought back and added a description for the "Exception" catalog type,
which is currently a singleton scalar type which can say that an
exception occurred but not any other metadata such as the kind of
exception. The type was added in the new main pod section "TYPES FOR
DEFINING EXCEPTIONS". Rewriting "Exception" to carry metadata is still
TODO, but in the meantime Muldis D code can at least throw and catch
exceptions and so use them for good program design.
* (Routines_Catalog.pod) Updated the "sys.std.Core.Cat.fail" procedure
to make its "Exception"-typed parameter optional; it will now throw the
default "Exception" value if the user doesn't supply some other one.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Formalized the syntax for
try-catch exception handling in procedures, which takes the form of a
pair of imperative routines where the first is executed unconditionally
and the second optional one iff the first throws an exception, where
the first exception is caught but the second isn't. Added the new pod
sub-section "Generic Try-Catch Statements" in the main pod section
"GENERIC PROCEDURE STATEMENTS", including a code example. In PTMD_STD,
this section introduced the main node kind "try_catch_stmt".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Formalized the syntax for
conditional statements in procedures, both the if-then-else and
given-when-then-default varieties. Added the 2 new pod sub-sections
"Generic [If-Else|Given-When-Default] Statements" in the main pod
section "GENERIC PROCEDURE STATEMENTS", including a code example for
each. In PTMD_STD, these sections introduced the 2 main node kinds
"if_else_stmt" and "given_when_def_stmt". These additions are just
like the similar-named functional analogies, but for being imperative.
* (Types_Catalog.pod) Updated the "LoopStmtNodeSet" catalog type to
rename its "do" attribute to "loop". Also updated the descriptions of
the 2 catalog types "[Leave|Iterate]StmtNodeSet", to remove a comment
about the first being able to "leave" itself, and to add a comment
about the second also being able to serve as a non-loop "redo" stmt.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Formalized the syntax for
iteration statements in procedures, specifically in the ad-hoc manner
of the 3 distinct "leave", "iterate", "loop" statement kinds. Added
the new pod sub-section "Procedure Leave, Iterate, and Loop Statements"
in the main pod section "GENERIC PROCEDURE STATEMENTS", including a
single code example for each file that combines the 3 node kinds (all
are also useable in isolation). In PTMD_STD, these sections introduced
the 3 main node kinds "leave_stmt", "iterate_stmt", "loop_stmt".
* (Basics.pod) Updated the "TYPE SYSTEM" main pod section to add a
couple paragraphs saying that one might say Muldis D uses "progressive
nominal typing" (thanks Larry Wall for coming up with that term)
with respect to values declaring their types but the associated type
constraints only apply if the types are defined, and that users never
have to define any data types as practically all Muldis D features are
enabled just through their ability to define routines, and so data
types mainly serve to provide constraints, say what users may *not* do.
* (Basics.pod, Types_Catalog.pod, PTMD_STD.pod) Added language support
for basic stimulus-response rules, namely just the variety that invokes
a routine in response to a depot mounting, which supports the bootstrap
of a pure Muldis D call chain. In Basics.pod, added new main pod
section "STIMULUS-RESPONSE RULES" to introduce this feature. In
Types_Catalog.pod, added the 2 new catalog types "StimRespRuleSet" and
"StimRespRule", the latter in the new main pod section "TYPES FOR
DEFINING STIMULUS-RESPONSE RULES", and updated the "Depot" type to add
a 14th attribute "stim_resp_rules". In PTMD_STD.pod, added new
material node kind "stim_resp_rule" and fully described its grammar
(save for a missing paragraph, TODO) plus an example, this in the new
pod sub-section "Stimulus-Response Rule Specification" under "MATERIAL
SPECIFICATION". Still TODO is add the corresponding sub-section in the
2 Perl-STD dialect files.
2010-05-01 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.124.0 is released on CPAN as
Muldis-D-0.124.0.tar.gz.
* This release features something that has been a long time in coming,
which is the addition of concrete syntax in all 3 Muldis D dialects for
specifying the scaffolding and interfaces/signatures of all 4 main
kinds of routines, as well as the concrete syntax for inlining a
material inside a routine ("with" clause). And so now the Muldis D
spec is complete with regard to how to specify all parts of atomic
routines (functions, updaters, recipes), meaning how to specify the
vast majority of database query and data manipulation code. This
release also adds to the specs of how to write nonatomic procedure
bodies, including lexical variable declarations and static value
assignments, and adds the ability to inline static values for arguments
to imperative routine invocations by procedures. Following this
release, which addresses the single largest remaining hole in the
Muldis D spec, subsequent releases only have left to address
progressively smaller holes. The first next release should add
concrete syntax for defining data types, meaning the vast majority of
database data definition code. After that would come things like
conditionals and loops in procedures, more kinds of constraints, more
on procedure exception handling, more on stimulus-response-rules, etc.
* (PTMD_STD.pod) Updated the "Material Reference Selector Expressions"
pod sub-section to clarify that a "material_ref" (and "curried_func")
node (in all 3 dialects) can take any primary namespace qualified name
chain as its "material_name" and will do the right thing; so when
you're starting with an "AbsPathMaterialNC" then the "material_ref"
will silently replace with a name-chain literal; this is particularly
useful so that any system-defined type or routine name "foo" that will
be used as a routine argument can just be written "<foo>" rather than
having to be "PNSQNameChain:foo".
* (Basics.pod, Types_Catalog.pod) Restricted a procedure so that it
can now only invoke a niladic function directly, and so invoking a
function with any parameters requires an updater or recipe
intermediary. In Basics.pod, updated 2 sentences in "Functions,
Updaters, Recipes, and Procedures" about this matter. In
Types_Catalog.pod, renamed the catalog type "FuncInvoStmtNodeSet" to
add the name-prefix "Nil", removed its "args" 5th attribute, and
updated its description. Also updated the "StmtNodeSet" catalog type
to rename its "func_invo_stmts" attribute adding th name-prefix "nil_".
* (Basics.pod, Types_Catalog.pod) In Basics.pod, updated the "Kinds of
Procedures" pod sub-section to add new routine kind "transaction" which
is a "procedure" that is its own lexical-scope-bound transaction but
isn't a "system-service". In Types_Catalog.pod, added corresponding
catalog type "sys.std.Core.Type.Cat.Transaction", which is a proper
subtype of "Procedure".
* (HDMD_Perl[6|5]_STD.pod) Fixed a fossil from release 0.123.0 where a
grammar detail in PTMD_STD was changed but the corresponding detail in
the 2 Perl dialects was not; the "depot_catalog_payload" node now
composes "named_material" rather than "material".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In the "Scalar Selectors"
pod sub-section, updated a couple code examples to use abbrev versions
of sys-def type names, to reflect more typical real-life usage.
* (HDMD_Perl[6|5]_STD.pod) Updated all code examples showing a
"function" node so that they reflect changes in the planned spec for
routine-specifying "material" nodes. The old plan grouped all the
details of a routine sans its name into a "payload" third (or second)
element of a "material" node, and for the "function" examples these
"payload" were arrays with the 3 elements: result type, parameters,
function body. The new plan groups all the payload elements except the
function body into a single function heading element, so that a payload
for a routine now always has exactly 2 elements. In HDMD_Perl6_STD,
the new "payload" is now a Perl "Pair" value, while in HDMD_Perl5_STD,
the new "payload" is expressed as a 2-element array ref that represents
a Pair without actually being one, same as some other 2-e in Perl5_STD.
* (HDMD_Perl5_STD.pod) In the "DEPOT SPECIFICATION" main pod section,
updated the second and third elements of a "depot" node
("depot-catalog" and "depot-data") so that each is now a 2-element Perl
array ref rather than a 1-element Perl hash ref; but the conception of
these hasn't changed, and is still intended to represent a Perl 6
"Pair" value (as HTMD_Perl6_STD still has) without actually being one.
Also updated any relevant code examples in that section plus in the
"CATALOG ABSTRACTION LEVELS" section.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Formalized the syntax for
static value expressions and assignments in procedures. Now it is
defined how to use a scalar literal or niladic function call directly
as a routine invocation read-only argument in a procedure, such that
corresponding lexical variables are automatically generated by the
parser (just variable names are allowed for subject-to-update arguments
as before). It is also defined now that the "iproc_imp_invo" grammar
node now is used to define tuples of 4 different "StmtNodeSet"
attributes; not just "ImpInvoStmtNodeSet" as before, but also
"[OVLScaVal|APMaterialNCSel|NilFuncInvo]StmtNodeSet"; the latter 3 are
used often when the node is invoking "assign"; it falls from this that
":=" syntax also works for all 3 when appropriate. Added the new pod
sub-section "Procedure Value Expressions" in the main pod section
"GENERIC PROCEDURE STATEMENTS"; also substantially updated the
sub-sections "Generic In-Procedure Imperative Invocation Statements"
and "Imperative Simple Non-symmetric Dyadic Infix Operators". In
PTMD_STD, these sections introduced 2 new main node kinds "proc_expr",
"var_name", "nil_func_invo", and "proc_stmt__plain_rtn_inv" was smplfd.
* (PTMD_STD.pod) Rearranged the grammar elements a small amount,
specifically be consolidating these 5 grammar nodes into the
otherwise-still-empty "Recipe Specification" pod sub-section:
"upd_cosigil" (from "Generic In-Multi-Update-Statement Imperative
Invocation Statements"), "lex_entity_name"+"data_sigil",
"infix_bind_op" (all 3 from "GENERIC VALUE EXPRESSIONS"),
"routine_name" (from "Generic Function Invocation Expressions").
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) As the single most-important
then-remaining Muldis D spec update to do, in all 3 STD.pod, completely
populated the 4 pod sub-sections "[Function|Updater|Recipe|Procedure]
Specification", thereby providing the complete grammar for all 4 main
routine kinds that had otherwise been missing, except for some portions
of a procedure body, which wouldn't have been in those sections anyway.
For all 4 main routine kinds, these additions supplied a complete
grammar for the scaffholding and public interfaces of those routines,
as well as how to embed other materials in them. As applicable,
specified how to declare read-only or subject-to-update parameters, and
regular or global parameters, and optional parameters, and dispatch
parameters (which declare the routine as virtual), declarations of
implementing other routines, declarations of lexical variables.
Specified routine bodies' lexical variables or procedural statements or
named expressions. Explained how the grammar mapped to the various
catalog types "Function", "Updater", "Recipe", "Procedure", etc. Each
of the 4 routine kinds has a complete code example for specifying a
complete routine of that type, in all 3 grammars; also demonstrated was
how to embed routines, how to perform recursion, how to run a query on
the database, how to output a message to the user. In PTMD_STD, these
sections introduced these new 29 main node kinds:
"[function|updater|recipe|procedure][|_[payload|heading|body]]",
"result_type", "[upd|ro]_[reg|global]_param", "param_name",
"[opt|dispatch]_param_flag", "global_var_name", "implements_clause",
"with_clause", "empty_routine_body", "proc_var".
2010-04-27 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.123.0 is released on CPAN as
Muldis-D-0.123.0.tar.gz.
* This release features the addition of concrete syntax in all 3 Muldis
D dialects for writing statements of imperative routines, particularly
ones for invoking imperative routines; both generic invocation syntax
for any imperative plus special alternate syntax for 11 imperatives
including the generic variable assignment operator ":=" are included.
This complements the long-existing concrete syntax for invoking
functions and writing value expressions. And so now the vast majority
of what one would normally write within a routine body is now specced.
The most important related thing still not specced is declaring the
scaffolding and interfaces/signatures of routines, as well as inlining
a routine inside a routine ("with" clause), and those are expected to
be delivered in the very next release. Also still not specced and not
to be delivered until later on include most kinds of statements one
would only find in a procedure that aren't routine invocations, such as
imperative conditionals and loops, especially loops.
* (Types_Catalog.pod) For each of the 4 catalog types "Function",
"Updater", "Recipe", "Procedure" updated the description with its
"dispatch_params" attribute to clarify that any given routine parameter
can not be both a dispatch parameter and an optional parameter.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In the "plain_rtn_inv" pod
sub-section, corrected a mistaken omission by adding "MATERIAL
SPECIFICATION" to the list of main pod sections whose grammar
constructs code at the "plain_rtn_inv" abstraction level may employ.
* (PTMD_STD.pod) Updated the "Material Specification Common Elements"
pod sub-section to add "transaction" as an option (subservient to
"procedure" like "system-service") to the "material_kind" grammar node.
* (PTMD_STD.pod) Multiple small grammar updates or refactors. Split
the "func_arg_list" grammar node into itself plus "func_arg", and
"expr_name" into itself plus "lex_entity_name". Renamed the
"param_name" node to "invo_param_name". The "depot_catalog_payload"
node now composes a "named_material" rather than a "material". The
"expr_core_options" node has been merged into the "expr__plain_rtn_inv"
node, and "expr__rtn_inv_alt_syn" now composes the latter rather than
the former. The "catalog__plain_rtn_inv" node now composes
"catalog__code_as_data" rather than "Database", which is composed by
its replacement anyway.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Basics.pod) In all 3 STD.pod,
added the 2 new main pod sections "GENERIC [UPDATER OR
RECIPE|PROCEDURE] STATEMENTS", which have the same role as "GENERIC
VALUE EXPRESSIONS" but that they describe the generic imperative
statement syntaxes rather than the generic value expression syntaxes;
the 2 new sections initially have no pod sub-sections. In PTMD_STD,
these sections introduced these new 4 main node kinds: "update_stmt",
"proc_stmt", "stmt_name", "named_stmt"; they also include example code
for the last 2 of those 4. In all 3 STD.pod, in the "plain_rtn_inv"
pod sub-section, added the 2 new main pod sections to the list of those
whose grammar constructs code at the "plain_rtn_inv" abstraction level
may employ. In Basics.pod, updated the main pod section "NOTES ON TEXT
CHARACTER LITERALS" concerning the "|" char, which is now the sigil for
statement node names as seen in "stmt_name", "named_stmt".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added the 2 new pod
sub-sections "Generic In-[Multi-Update-Statement|Procedure] Imperative
Invocation Statements", one each respectively in the 2 main pod
sections "GENERIC [UPDATER OR RECIPE|PROCEDURE] STATEMENTS"; these have
the same role as "Generic Function Invocation Expressions" but that
they are for invoking imperative routines rather than functions. In
PTMD_STD, these sections introduced these new 2 main node kinds:
"imus_imp_invo", "iproc_imp_invo"; they both also include example code.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added the new main pod
section "IMPERATIVE INVOCATION ALTERNATE SYNTAX STATEMENTS", which has
the same role as "FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS" but
that it describes special syntaxes for invocations of imperative
routines rather than of functions; the 2 new sections initially have no
pod sub-sections. In the "rtn_inv_alt_syn" pod sub-section, added the
new main pod section to the list of those whose grammar constructs code
at the "rtn_inv_alt_syn" abstraction level may employ. In PTMD_STD,
the new section introduced the new main node kind
"imp_invo_alt_syntax". In PTMD_STD.pod, also split each of the 2
grammar nodes "update_stmt", "proc_stmt" 3 ways, into itself plus
otherwise-same-named variants suffixed with "__plain_rtn_inv" or
"__rtn_inv_alt_syn", and tied those triples to the current catalog
abstraction level, such that the "__plain_rtn_inv" variant was the same
as the pre-split node, and the "__rtn_inv_alt_syn" variant adds to that
the "imp_invo_alt_syntax" grammar options.
* (Ordered.pod, Integer.pod, Boolean.pod) In Ordered.pod, added the
new main pod section "VIRTUAL UPDATERS FOR THE ORDINAL MIXIN TYPE"
which includes the 2 new virtual updaters
"sys.std.Core.Ordered.Ordinal.assign_[pred|succ]". In each of
Integer.pod and Boolean.pod, added the new main pod section "UPDATERS
IMPLEMENTING VIRTUAL ORDINAL FUNCTIONS" which includes 2 new updaters
which implement the 2 virtuals and have the same unqualified names.
These new updaters provide the exact same functionality as the "--" and
"++" monadic operators common to programming languages which decrement
or increment a var; Muldis D's existing "pred|succ" weren't mutators.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the main pod section
"IMPERATIVE INVOCATION ALTERNATE SYNTAX STATEMENTS", added the 2 new
pod sub-sections "Imperative Simple [Monadic Postfix|Non-symmetric
Dyadic Infix] Operators". The additions provide concrete syntaxes
specific to these 11 updaters: 2 "Ordinal.assign_[succ|pred]" as
":=++",":=--", 1 "Universal.assign" as ":=", 8 "Relation.assign_\w+";
the unique parts of the latter 8's names being: "union", "restriction",
"cmpl_restr", "intersection", "diff", "semidiff", "semijoin",
"exclusion". In PTMD_STD, the 2 new sub-sections introduced the 2 new
main node kinds "imp_[monadic_postfix|nonsym_dyadic_infix]_op_invo";
both new sections included example code.
* (Relation.pod, Universal.pod, Ordered.pod) Added also-known-as notes
for 11 assign/assign-shorthand updaters in correspondence to previous
change item.
2010-04-25 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.122.0 is released on CPAN as
Muldis-D-0.122.0.tar.gz.
* (Routines_Catalog.pod) Added the 2 functions
"sys.std.Core.Cat.curried_func_[invo|static_exten]" which make it
easier to work with higher-order functions.
* (PTMD_STD.pod, Routines_Catalog.pod, Relation.pod) In PTMD_STD.pod,
updated the "Simple Non-symmetric Dyadic Infix Operators" pod
sub-section to add special infix-op syntax for 3 functions; the new ops
"assuming","where","[!|not-]where" map respectively to
"curried_func_static_exten", "Relation.[restriction|cmpl_restr]". In
the other 2 files, updated the also-known-as notes for th same 3 funcs.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Basics.pod) A change that was
a long time in coming. In all 3 STD.pod, rewrote the pod sub-section
"Library Entity Reference Selector", in the process renaming it to
"Material Reference Selector Expressions", and renaming the node
"lib_entity_ref_selector" to "material_ref_sel_expr". Merged the 5
PTMD_STD node formats "[F|U|P|T|ODF]->foo" to the one "<foo>", since
behind the scenes they all would turn into the same thing anyway as of
release 0.79.0; also, the two Perl-STD formats now use the one
"['material-ref','foo']" rather than the 5
"['[func|upd|proc|type|ord-det-func]-ref','foo']"; this common format
is the "material_ref" node kind. Also in that pod sub-section added
the new node kind "curried_func", an example of which looks like
"<foo>( bar => $baz )" or "['curried-func','foo',{bar=>['$','baz']}]";
this essentially is a "material_ref" which is then curried with some
bound arguments; the latter is the typical form of higher-order
functions. Also brought any code examples up to date that had used the
old "->" formats. In Basics.pod, updated the main pod section "NOTES
ON TEXT CHARACTER LITERALS" concerning the "<>" chars and others.
2010-04-24 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.121.0 is released on CPAN as
Muldis-D-0.121.0.tar.gz.
* This release features the purge of all temporal concerning features
except for the temporal mixin types and virtual routines; all non-mixin
temporal types, all non-virtual temporal routines, and the temporal
standard syntax extension in all 3 concrete grammars were removed. But
not lost; these removed bits will soon be put in a file in the
Muldis::D::Manual distribution, ostensibly in case someone wants to
derive from them a user-defined extension or something. The primary
reason for this move is that details of the Gregorian calendar et al
are too complicated and too subject to change to define in a core
programming language spec, and are best left to separate modules; and
even if not, the existing TAI/UTC types needed a huge refactor anyway.
As a result of this purge, the spec was made smaller by 53K of text in
its lib/ dir, which is 5% of its release-0.120.0 lib/ size.
* (Temporal.pod) Updated the 2 mixin types "Instant","Duration" so
that their default values are now implementation-defined. This also
affects the type of "Instant.fetch_curr_instant" when its "target"
argument has the declared type of "Instant"; the fetched datetime would
have the same type as the implementation-defined default value.
* (Types_Catalog.pod) Updated the "OVLScalar" catalog type to remove
the 5 values "[TAI|UTC|Float]Instant", "[TAI|UTC]Duration".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In all 3 STD.pod, completely
removed the "temporal" standard syntax extension, which provided
special value literal syntax to all the system-defined non-mixin
temporal types. Removed the whole main pod section "TEMPORAL EXTENSION
OPAQUE VALUE LITERALS", which had a sub-section "Date and Time
Literals", and declared the 5 value node kinds
"[TAI|UTC|Float]Instant", "[TAI|UTC]Duration". Also updated the main
pod section "STANDARD SYNTAX EXTENSIONS" to first remove the pod
sub-section "temporal" and then to say that there are currently zero
standard syntax extensions; also updated the "LANGUAGE NAME" main pod
section to say likewise on the latter. Also updated a "Scalar" code
example to make "UTCDateTime" into a user-defined type.
* (Temporal.pod) Removed most of the DESCRIPTION and TYPE SUMMARY main
pod sections, leaving shorter versions. Removed these 6 entire main
pod sections: "DATA TYPES FOR TEMPORAL ARTIFACTS", "FUNCTIONS
IMPLEMENTING VIRTUAL [ORDERED|INSTANT|DURATION] FUNCTIONS", "FUNCTIONS
FOR CONVERSION BETWEEN UTC AND TAI", "SYSTEM-SERVICES IMPLEMENTING
VIRTUALS FOR CURRENT DATES AND TIMES". With those sections, these 16
non-mixin types were removed: "PInt[12|31]", "NNInt[23|59]",
"NNRatLT62", "TAI[Instant|Duration]",
"[UTC|Float][Instant|DateTime|Date|Time]", "UTCDuration"; also, these
27 non-virtual functions were removed: 15
"[TAI|UTC|Float]Instant.[order|[|abs_]diff|[lat|earli]er]", 10
"[TAI|UTC]Duration.[order|abs|sum|[|abs_]diff]", 2
"UTCInstant.[UTC_from_TAI|TAI_from_UTC]"; also, these 7 non-virtual
system-service routines were removed: TAIInstant.fetch_curr_instant",
"[UTC|Float]Instant.fetch_curr_[datetime|date|time]".
* (PTMD_STD.pod) Updated the "Material Specification Common Elements"
pod sub-section to add "database-type" as an option (subservient to
"tuple-type") to the "material_kind" grammar node.
2010-04-23 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.120.0 is released on CPAN as
Muldis-D-0.120.0.tar.gz.
* This release features the addition of the 2 system-defined mixin
types "Instant" and "Duration", and so now users can do common temporal
concerning things in a completely calendar-agnostic manner, and the
temporal-concerning parts of the language are now less kludgy.
* (Temporal.pod) Added the 2 new mixin types
"sys.std.Temporal.Type.[Instant|Duration]" in a new main pod section
"TEMPORAL MIXIN DATA TYPES". Also updated the descriptions of the 3
scalar types "[TAI|UTC|Float]Instant" so that they directly compose
"Instant", and the 2 scalar types "[TAI|UTC]Duration" so that they
directly compose "Duration". Also updated "TYPE SUMMARY".
* (Temporal.pod) Added the 2 new main pod sections VIRTUAL FUNCTIONS
FOR THE [INSTANT|DURATION] MIXIN TYPE, which include 4 new virtual
functions each, which are
"sys.std.Temporal.Instant.[[|abs_]diff|[lat|earli]er]" and
"sys.std.Temporal.Duration.[abs|sum|[|abs_]diff]", respectively. Also
split the main pod section "FUNCTIONS FOR TEMPORAL MATH" into the 2
"FUNCTIONS IMPLEMENTING VIRTUAL [INSTANT|DURATION] FUNCTIONS", which
got 12 and 8 of its functions, respectively; for each of those 20
functions, updated that function so that it implements the new function
with the same partially-qualified name.
* (Temporal.pod) Added new main pod section "VIRTUAL SYSTEM-SERVICES
FOR CURRENT DATES AND TIMES" which includes 1 new virtual
system-service routine "sys.std.Temporal.Instant.fetch_curr_instant".
Also renamed the main pod section "SYSTEM-SERVICES FOR CURRENT DATES
AND TIMES" to "SYSTEM-SERVICES IMPLEMENTING VIRTUALS FOR CURRENT DATES
AND TIMES" and updated each of its 7 system-services so that it
implements the new system-service.
* (Core.pod, README) Updated recommended reading order of core files.
* (Relation.pod) Updated the 2 functions "rank[|_by_attr_names]" to
add a "first_rank" parameter, letting you customize at which starting
number the generated rank numbers begin; this should help with using
"rank" as a generator of non-descriptive id attributes for a set of
records to insert where the ids don't conflict with existing-used ones.
2010-04-19 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.119.0 is released on CPAN as
Muldis-D-0.119.0.tar.gz.
* (Routines_Catalog.pod) In a reversal of one aspect of release
0.117.0, split the 1 "imp_invo" routine into the 3
"[upd|rcp|proc]_invo"; because this language feature takes the form of
an ordinary routine, it must follow ordinary routine rules, which
include that updaters can't invoke recipes or procedures, etc, and so
each of the 3 imperative routine kinds needs its own "_invo".
* (Routines_Catalog.pod) Made "fail" into a procedure rather than a
recipe; it isn't a valid recipe because it never updates a variable;
also it can only reasonably be invoked by a procedure anyway.
* (Types_Catalog.pod) Updated the catalog type "Recipe" to rename its
2 "[upd|ro]_globals" attributes to "[upd|ro]_global_params"; also moved
those upwards in the attribute list to just follow "opt_params".
* (Routines_Catalog.pod) Updated all 25 of the system-defined recipes
which would directly access global variables as implicit parameters so
that the recipes' signatures explicitly declare which globals they
access, resembling a normal param declaration. This corresponds to
planned PTMD_STD additions which would formalize that recipe
declarations must have said globals decls. This change has no impact
on how one would invoke a recipe. Each updated recipe declared 1 or 2
global-params, which are 1 or 2 each of "&$mounts ::= $mnt.cat.mounts",
"&$cat ::= $fed.cat", "&$data ::= $fed.data".
* (Types_Catalog.pod) Updated the descriptions of the 4 catalog types
"Function","Updater","Recipe","Procedure" to clarify that a routine
body must not be specified if that routine is virtual.
* (Universal.pod, Scalar.pod, Boolean.pod, Integer.pod, Rational.pod,
Blob.pod, Text.pod, Cast.pod, Tuple.pod, Relation.pod, Set.pod,
Array.pod, Bag.pod, Interval.pod, STDIO.pod, Routines_Catalog.pod,
Ordered.pod, Numeric.pod, Stringy.pod, Counted.pod, Temporal.pod)
Reformatted all system-defined routine declarations to match the
planned new PTMD_STD format for declaring "stub" routines that lack
routine bodies, which is to simply have "..." as the entire routine
body. This is inspired by Perl 6, whose "yadayadayada" operator
spelled "..." will compile as valid code but throw an exception if
executed, saying the likes of "this routine isn't implemented", so
reading it means exactly the same thing to programmers and to the
computer, that something is missing. In Muldis D, writing for example
"updater foo (&$bar@ : Numeric) {...}" will compile as valid code,
represented in the system catalog as a virtual updater with no body.
In general many system-defined routines would be implementation-defined
and have no body defined in Muldis D, but for the sake of brevity all
of the documented signatures will declare no body in pretend.
2010-04-17 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.118.0 is released on CPAN as
Muldis-D-0.118.0.tar.gz.
* This release features the addition of the 2 system-defined mixin
types "Numeric" and "Stringy"; the former would be composed by types
like "Int" and "Rat", while the latter would be composed by types like
"Blob" and "Text". Related to this, the concrete grammars concerning
math and string ops have been consolidated and greatly improved.
* (PTMD_STD.pod) In the "DBMS Entity Name Literals" pod sub-section,
updated the paragraph about the first special case of "PNSQNameChain"
supporting abbreviated chains, to say that if there are multiple
in-core routines with the same unqualified name, then that unqualified
name may be used for a routine invocation iff exactly 1 of the
candidates is a virtual routine and the other candidates implement it;
the invocation would then resolve to the virtual routine.
* (PTMD_STD.pod) Updated the "NESTING PRECEDENCE RULES" main pod
section to give bullet-headings to the 7 precedence levels: "Terms",
"P[ost|re]fix", "[Dyadic|Reducing] Infix", "Conditional", "Naming".
* (Integer.pod, Rational.pod, Ordered.pod, Relation.pod, Set.pod,
Array.pod, Bag.pod, Counted.pod) Removed all 14 "maybe_" variants of
built-in functions in order to simplify the language. Between
Integer.pod and Rational.pod, 6 functions that would fail due to a
division by zero had counterparts that wrapped the normal result in a
Maybe and resulted in nothing when said failure would otherwise occur:
"[Integer|Rational].maybe_[quotient|mean]",
"Integer.maybe_[remainder|quot_and_rem]"; instead of using those, users
can just invoke the normal versions conditionally based on an easily
testable input. In Ordered.pod, 3 N-ary functions that would result in
special infinity values as identities if they have zero inputs have
counterparts that wrapped the normal result: "maybe_[min|max|minmax]";
users should use the normal versions and either conditionally invoke
them or conditionally test the results. In each of the other 5 pod
files, there was a single generic reduction operator that took an
explicit identity value argument, and a variant saved the need for that
argument by resulting in a Maybe:
"[Relation|Set|Array|Bag].maybe_reduction",
"Counted.counted_maybe_reduction"; use the normal versions instead.
* (Integer.pod, Rational.pod) Corrected each of the 2 functions
"sys.std.Core.[Integer|Rational].range" so that it now fails if given
zero inputs rather than resulting in zero; while a range of zero is the
correct answer for a single-element set, a zero-elem set has no range.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In all 3 STD.pod, renamed the
"Rational Operators That Do Rounding" pod sub-section to substitute in
"Numeric", and renamed all grammar nodes that it declared from
containing "rat_op" to containing "num_op".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Integer.pod, Basics.pod)
Regarding the "Integer.remainder" function, eliminated the alternate
infix op syntax "%" and instead standardized on "mod" for that purpose.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Integer.pod, Rational.pod)
Renamed the alternate syntaxes for all 5 math functions that do either
division or exponentiation. The spellings were changed as follows:
"i/" -> "div", "r/" -> "/", "i^" -> "exp", "r^" -> "**", "e^" -> "e**".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the concrete grammars
to reflect that the integer division and modulo operators have a
mandatory "round_meth" 3rd parameter; this completes a spec change
begun in release 0.113.0, where the function sigs gained the parameter.
In all 3 STD.pod, moved "div" and "mod" from the "Simple Non-symmetric
Dyadic Infix Operators" pod sub-section to "Numeric Operators That Do
Rounding", with appropriate grammar and example code updates.
* (Integer.pod, Rational.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod,
Basics.pod) In Integer.pod, renamed each of the 3 functions
"quotient", "mean", "mean_of_median" to prepend "whole_". In
Rational.pod, renamed each of the same 3 functions to prepend "frac_".
In all 6 files, updated any references to the renamed as appropriate.
* (Integer.pod, Rational.pod) Added 8 numeric functions and tweaked
the descriptions of others so to bring the complement of integer and
rational functions as much in sync with each other as is reasonably
possible, and otherwise fill in some related functionality gaps. In
Integer.pod, added these 3 functions: "frac_quotient", "frac_mean",
"frac_mean_of_median". In Rational.pod, added these 3 functions:
"whole_quotient", "remainder", "quot_and_rem". In both files, added
the 1 function "power_with_whole_exp".
* (Types.pod) In Types.pod, added new mixin type
"sys.std.Core.Type.Numeric" in the main pod section "GENERIC MIXIN DATA
TYPES". Also updated the descriptions of the 2 scalar types
"Int","Rat" so that they directly compose "Numeric". Also updated the
"TYPE SUMMARY".
* Added new initially-empty file Core/Numeric.pod whose purpose is to
consolidate the main virtual routines associated with the "Numeric"
type. Updated Core.pod and the README file to reflect the added file.
* (Numeric.pod, Integer.pod, Rational.pod) In Numeric.pod, added new
main pod section "VIRTUAL FUNCTIONS FOR THE NUMERIC MIXIN TYPE" which
includes 15 new virtual functions in the "sys.std.Core.Numeric.\w+"
namespace: "abs", "sum", "[|abs_]diff", "product",
"[frac|whole]_quotient", "remainder", "quot_and_rem", "range",
"frac_mean", "median", "frac_mean_of_median", "mode",
"power_with_whole_exp". In each of Integer.pod and Rational.pod,
updated each of the 15 functions with the same unqualified names so
that it implements the same-named new function, and wrapped up the 15
functions into the new main pod section "FUNCTIONS IMPLEMENTING VIRTUAL
NUMERIC FUNCTIONS". Following these changes, in Integer.pod, the main
pod section "FUNCTIONS FOR INTEGER MATH" now just has these 4
functions: "whole_mean[|_of_median]", "power", "factorial"; in
Rational.pod, the main pod section "FUNCTIONS FOR RATIONAL MATH" just
has these 5 functions: "round", "[|natural_][power|log]".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Numeric.pod, Integer.pod,
Rational.pod) Reorganized all of the special alternate function
syntaxes that had belonged to any of the 30 math functions that gained
a virtual analogy, so that now only the latter have associated special
syntaxes and the former now don't. The following 5
"Integer","Rational" pairs of syntaxes
were consolidated into a single "Numeric" syntax each:
"[i|r][+|*|-]" -> "[+|*|-]", "i|-|","r|-|" -> "|-|",
"i||","r||" -> "||". The 2 syntaxes "div","mod" were simply moved from
"Integer" to "Numeric", and the 1 "/" from "Rational" to "Numeric".
The 1 new syntax "^" was added initially in "Numeric", for the
"power_with_whole_exp" function.
* (Types.pod, Types_Catalog.pod) In Types.pod, added new mixin type
"sys.std.Core.Type.Stringy" in the main pod section "GENERIC MIXIN DATA
TYPES". Also updated the descriptions of the 2 scalar types
"Blob","Text", and the 1 nonscalar type "Array", so that they directly
compose "Stringy". In Types_Catalog.pod, updated the descriptions of
the 4 scalar types "String","Name","NameChain","Comment" so that they
directly compose "Stringy". Also updated "TYPE SUMMARY" in both files.
* Added new initially-empty file Core/Stringy.pod whose purpose is to
consolidate the main virtual routines associated with the "Stringy"
type. Updated Core.pod and the README file to reflect the added file.
* (Stringy.pod, Blob.pod, Text.pod, Array.pod) In Stringy.pod, added
new main pod section "VIRTUAL FUNCTIONS FOR THE STRINGY MIXIN TYPE"
which includes 2 new virtual functions in the
"sys.std.Core.Stringy.\w+" namespace: "catenation", "replication". In
each of Blob.pod, Text.pod, and Array.pod, updated each of the 2
functions with the same unqualified names so that it implements the
same-named new function, and wrapped up the 2 functions into the new
main pod section "FUNCTIONS IMPLEMENTING VIRTUAL STRINGY FUNCTIONS".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Stringy.pod, Blob.pod,
Text.pod, Array.pod) Reorganized all of the special alternate function
syntaxes that had belonged to any of the 6 stringy functions that
gained a virtual analogy, so that now only the latter have associated
special syntaxes and the former now don't. The following 2
"Blob","Text","Array" triples of syntaxes were consolidated into a
single "Stringy" syntax each: "[b|t|a][~|-x]" -> "[~|x]".
2010-04-11 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.117.0 is released on CPAN as
Muldis-D-0.117.0.tar.gz.
* (PTMD_STD.pod) Fixed 2 mistakes in the "OPERATOR CHARACTER
REPERTOIRE" main pod section that release 0.116.0 introduced.
* (Types_Catalog.pod, Routines_Catalog.pod) Large simplification to
the Muldis D abstract grammar / system catalog such that the process of
invoking an imperative routine (updater, recipe, or procedure) has been
normalized, so there is now a common syntax for all imperative routine
kinds rather than a separate one for each; you can no longer tell what
kind of imperative routine that code is invoking by its syntax, but
rather just by either the routine name or the kind of routine doing the
invoking. The prior design essentially had gratuitous strong typing
where there was distinct but alike syntax for invoking each kind of
routine; but for that purpose it wasn't worth it as other tests would
have to be done anyway, and the latter will now just be the only tests,
and sufficient themselves. In Types_Catalog.pod, merged the 2 nearly
identical catalog types "Multi[Upd|Rcp]InvoStmt" into the 1
"MultiUpdStmt" (which is also a reversal of one aspect of release
0.115.0), and the 3 "[Upd|Rcp|Proc]InvoStmtNodeSet" into the 1
"ImpInvoStmtNodeSet", and the 6 "[A|R]P[Updater|Recipe|Procedure]NC"
into the 2 "[A|R]PImperativeNC". Also updated the catalog type
"Recipe" to merge its 2 attributes "stmt_part_[upd|rcp]" into the 1
"stmt". Also updated the catalog type "StmtNodeSet" to merge its 3
attributes "[upd|rcp|proc]_invo_stmts" into the 1 "imp_invo_stmts". In
Routines_Catalog.pod, merged the 3 routines "[upd|rcp|proc]_invo" into
the 1 "imp_invo".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In all 3 STD.pod, updated the
"DBMS Entity Name Literals" pod sub-section to remove the special case
of a "PNSQNameChain" value node kind where it might be interpreted with
a "topic" chain element prepended. In the 2 Perl-STD, this shorthand
is now just gone and you'll have to write "topic.attr" rather than
".attr". In PTMD_STD, also updated the "Generic Expression Attribute
Accessors" pod sub-section to add a variant of the acc-via-named format
that restores the "topic"-prepending shorthand which was removed from
PNSQNameChain, but for PTMD_STD only. Considering other recent spec
changes, an attribute-accessor is the *only* place where ".attr" could
have been used anyway.
* (Types_Catalog.pod) Updated the catalog type "DataNC" to change its
default value from "lex.topic" to "sys.cat" (which is also a reversal
of one aspect of release 0.115.0).
* (Basics.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)
Further simplified the system catalog and all standard grammars by
eliminating completely the "lex" primary entity namespace as something
that is actually used in entity references in code. Release 0.115.0
had mostly put the nails in its coffin and the current release is
basically cleaning up and removing the last vestiges, because "lex" is
now completely redundant for actual use, as any context that lets you
reference a lexical entity can't reference anything but a lexical
entity, and likewise for not-lexical entities. In Basics.pod, split
the pod sub-section "User-Defined Entities" in 2, with the last
paragraph, about "lex", forming a new pod sub-section "Lexical
Entities", which was then expanded to explain that "lex" is now just a
concept and is no longer actually useable in code; similarly updated
the namespace graph under "ENTITY NAMES". In Types_Catalog.pod,
removed the catalog type "LexDataNC", and updated each catalog type
having an attribute of "LexDataNC" so that said attribute's declared
type is now "Name" instead, except for just "AccExprNodeSet" where its
"target" attribute is now a "NameChain" instead. Also updated each of
the 3 catalog types "PNSQNameChain", "DataNC", "SysNspSet" to remove
"lex[|.*]" from its value list. In all 3 STD.pod, updated the
"PNSQNameChain" value node kind to remove "lex.*" from its value list,
and remove the special shorthand syntax where it might be interpreted
with a "lex" chain element prepended. Also updated the
"AccExprNodeSet" node kind to change its last element's kind from
"PNSQNameChain" to "NameChain".
2010-04-07 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.116.0 is released on CPAN as
Muldis-D-0.116.0.tar.gz.
* This release partly features the addition of an initial complement of
system-defined mixin types, specifically "Ordered" and "Ordinal", where
the latter is a more specific example of, and composes, the former. A
type would compose "Ordered" if it is an ordered type, such that you
can take all of its values and arrange them on a line in some
definitive order where every value can be said is "before" all values
on one side and "after" all values on the other side. A type would
compose "Ordinal" if it is an ordinal type, such that between every
pair of values there is a known finite count of values between them,
and those can be enumerated in order. Ordered/ordinal types tend to be
scalar types, but they don't have to be. Ordered types like "Bool" and
"Int" are also ordinal, while ordered types like "Rat", "Blob", "Text"
are not also ordinal. Further to this new feature, various
ordered-sensitive functions were refactored, such that we see the first
system-defined virtual functions and implementing counterparts; the
"order" virtual is for all ordered types, and the two "pred","succ" for
"ordinal". And so, now "order"/"<=>" in particular is now a properly
elegant generic overloaded operator such as any user can make, rather
than a special case with specific support in the system catalog. And
"--","++" ("pred","succ") are no longer integer-specific.
* This release partly features large enhancements to the system catalog
and concrete grammars that improve support for the preservation of
non-behaviour-impacting metadata in Muldis D source code, such as code
comments and code element ordinal positions, which is important for
helping the code to be easier to read and update by programmers, and
for helping deparsed or translated code better resemble the original.
(Actually, some of the intended improvements for comments didn't make
it, so they are pending in a future release.)
* (Routines_Catalog.pod) Updated the "create_depot_mount" recipe to
add the boolean parameter "allow_auto_run"; this should have been done
in release 0.114.0 but wasn't.
* (Types_Catalog.pod, Basics.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)
In Types_Catalog.pod, added the 2 new singleton scalar types
"sys.std.Core.Type.Cat.[-Inf|Inf]", which are canonical minimum-most
and maximum-most values for the entire Muldis D type system; they would
compare as "before" or "after" all other "Universal" values,
respectively. Also added the new union type
"sys.std.Core.Type.Cat.Singleton" which ranges over just the 2 new
infinity values for now. In Basics.pod, updated the "NOTES ON TEXT
CHARACTER LITERALS" main pod section to add "∞" to the list. In all 3
STD.pod, added new pod sub-section named "Singleton Literals" to the
start of the main pod section "OPAQUE VALUE LITERALS", which declares
specific literal/selector syntax, as a new "Singleton" value node kind,
for every singleton value that "Singleton" ranges over, in this case
just "-Inf" and "Inf". Also in PTMD_STD.pod, made "Singleton" the 9th
value node kind whose values may all omit the "value_kind" portion of a
GCVL for brevity. Also in HDMD_Perl6_STD.pod, added the 2 special Perl
6 values "-Inf" and "Inf|+Inf" to the data types for which a GCVL may
alternately be just its payload for brevity. Also in
Types_Catalog.pod, updated the catalog type "OVLScalar" to add
"Singleton" to what it ranges over.
* (Types.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In Types.pod,
updated the 2 data types "[S|M]PInterval" so that they now also support
unbounded/infinite intervals, which is accomplished by using the 2 new
infinity values "-Inf", "Inf" as interval endpoints. Also changed the
default value of "SPInterval" to have "Inf" and "-Inf" for its "min"
and "max" attributes, rather than "True" and "False"; it still
represents the empty interval, same as before, though. In all 3
STD.pod, updated the "Interval Selectors" pod sub-section to add a new
code example demonstrating an unbounded multi-part interval literal.
* (Ordered.pod) Updated the 3 functions "min|max|minmax" to use the 2
new infinity values, as appropriate, as identity values when the
functions' topic arguments have zero elements, rather than the
functions failing.
* (Types.pod, Types_Catalog.pod, Temporal.pod) In Types.pod, added new
main pod section "GENERIC MIXIN DATA TYPES", just prior to "GENERIC
SCALAR DATA TYPES", which declares the 2 new mixin types
"sys.std.Core.Type.Ord[ered|inal]". Also updated the descriptions of
the 5 scalar types "Bool","Int","Rat","Blob","Text" so that the last 3
directly compose the "Ordered" type and the first 2 directly compose
the "Ordinal" type (and indirectly the "Ordered" type). In
Types_Catalog.pod, updated the descriptions of the 7 scalar types
"String","Name","NameChain","Comment","Order","-Inf", "Inf" so that the
first 4 directly compose "Ordered" and the last 3 directly compose
"Ordinal". In Temporal.pod, updated the descriptions of the 5 scalar
types "[TAI|UTC|Float]Instant", "[TAI|UTC]Duration" so that they
directly compose "Ordered". In all 3 files, updated "TYPE SUMMARY" to
add a graph slice showing types composing mixins grouped by the latter.
* (Ordered.pod, Scalar.pod, PTMD_STD.pod, Array.pod, Interval.pod,
Tuple.pod, Types_Catalog.pod) Moved the function
"sys.std.Core.Scalar.order" from Scalar.pod to Ordered.pod, in the
process renaming it to "sys.std.Core.Ordered.order". Updated the
references to that function in 6 files to use the new name.
* (Ordered.pod, Types_Catalog.pod, Boolean.pod, Integer.pod,
Rational.pod, Blob.pod, Text.pod, Temporal.pod) In Ordered.pod,
redefined the "order" function to specifically say that it is a virtual
function; updated its signature to specify this by adding the "@"
character to the end of the "topic" and "other" parameters, which
designates them as "dispatch params", and having at least one of those
is part of how a routine is marked as virtual (besides having no
defined routine body); also wrapped "order" in a new main pod section
"VIRTUAL FUNCTIONS FOR THE ORDERED MIXIN TYPE", and updated its
description. In Types_Catalog.pod, updated each of the 2 catalog types
"[Scalar|Domain]Type" to remove its "order" attribute, since an ordered
type no longer specifies its default order-determination function in
the type definition itself. In each of the other 6 files, added a new
main pod section "FUNCTIONS IMPLEMENTING VIRTUAL ORDERED FUNCTIONS"
which contains one or more functions with "order" unqualified names,
each of which has a signature like the virtual "order" but for more
specific types, no "@", and "implements sys.std.Core.Ordered.order"
appended, which is how the virtual-implementer association is defined;
Temporal.pod had 5 "order" functions, for its 5 main types, and the
other 5-of-6 files have one "order" function each.
* (Ordered.pod, Integer.pod, PTMD_STD.pod, Boolean.pod) In
Ordered.pod, added new main pod section "VIRTUAL FUNCTIONS FOR THE
ORDINAL MIXIN TYPE" which includes the 2 new virtual functions
"sys.std.Core.Ordered.Ordinal.[pred|succ]"; these functions are
generalized copies of Integer.pod's "sys.std.Core.Integer.[pred|succ]";
in Integer.pod, updated the latter 2 functions to make them implement
the 2 new functions rather than being standalone, and wrapped up the
latter 2 in a new main pod section "FUNCTIONS IMPLEMENTING VIRTUAL
ORDINAL FUNCTIONS". In PTMD_STD.pod, and the first 2 files, reflected
that the special postfix alternate function syntaxes "--","++" are now
for "Ordinal.[pred|succ]" rather than the "Integer" versions. In
Boolean.pod, added the 2 "sys.std.Core.Boolean.[pred|succ]" functions
in their own new "... ORDINAL ..." main pod section.
* (Scalar.pod) Updated all of the function signatures having a
"possrep" parameter so that any other parameters whose declared type
was "Scalar" is now "ScalarWP" instead.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the pod sub-section
"Generic If-Else Expressions" to update a code example to use a specced
"is_empty" func-invo node instead of unspecced "is-empty" alt-syn node.
* (Temporal.pod) Added the 2 new functions
"sys.std.Temporal.[TAI|UTC]Duration.abs_diff", so now every temporal
type consistently has at least the 2 functions "diff" and "abs_diff".
* (D.pm, Basics.pod, Types.pod, Types_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod, Counted.pod) Fixed all misspellings of
'metadata' (using 'meta-data' was incorrect).
* (Types_Catalog.pod, PTMD_STD.pod) Updated every (nonscalar) catalog
type having a "comment" attribute to rename th latter to "scm_comment".
* (Types_Catalog.pod) Updated each of these 2 (nonscalar) catalog
types to add a "scm_comment" (source code metadata code comment)
attribute: "RcpGlobalVarAliasMap", "NameTypeMap". And so, one can now
attach a comment specifically to a declaration of a single type
attribute or routine parameter or variable, etc.
* (Types_Catalog.pod) Updated each of these 52 (nonscalar) catalog
types to add a "scm_vis_ord" (source code metadata visual element
order) attribute, of type "NNInt": "Sys[Nsp|SpecType|Cat]Set",
"SubdepotSet", "[|Sys][Function|Updater|Recipe|Procedure]Set",
"[|Sys][Scalar|Tuple|Relation|Domain|Subset|Mixin]TypeSet",
"OVLScaValExprNodeSet",
"[Sca|Tup|Rel|Set|Ary|Bag|[S|M]PIvl|List]SelExprNodeSet",
"[Acc|FuncInvo|IfElse|GivenWhenDef|APMaterialNCSel]ExprNodeSet",
"Multi[Upd|Rcp]InvoStmt", "RcpGlobalVarAliasMap", "PossrepSet",
"VirtualAttrMapSet", "[|Distrib][Key|SubsetConstr]Set", "NameTypeMap",
"NameExprMap", "NameNCMap", "AttrRenameMap".
* (Basics.pod, PTMD_STD.pod) In Basics.pod, added new main pod section
near the end named "SOURCE CODE METADATA", with the initial 2
sub-sections "Code Comments" and "Visual Element Order"; these outline
how the Muldis D system catalog supports the storage of explicit
metadata, currently code comments and ordinal code element positions,
that has no impact on the behaviour of the code but is important for
human readers or updaters of the code; these also provide some detail
the intended interpretation of this metadata and how concrete grammars
should work with it. In PTMD_STD.pod, added a paragraph to the
"plain_rtn_inv" pod sub-section to say that parsers which support this
or higher catalog abstr levels should preserve all prev desc metadata.
2010-04-02 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.115.0 is released on CPAN as
Muldis-D-0.115.0.tar.gz.
* This release features a redefinition of "recipe" to become the 4th
main routine kind (besides function, updater, procedure), rather than
being a special case of a procedure. A "recipe" is now firmly between
an updater and a procedure; it is exactly the same as an updater except
that it can see and update global variables; moreover, a procedure has
been stripped of the ability to do that directly; a procedure must now
invoke a recipe to use the database. From now on, it is expected that
most typical user code, that analogous to typical database query or
data manipulation or data definition code, would now be written
primarily as recipes, since a single recipe can do everything that is
possible in Muldis D to do as a single atomic and deterministic action.
Now, the only reason to write a "procedure" is if you want to write
something nonatomic or nondeterministic natively in Muldis D; in
general practice for a mixed-language application, you would tend to do
nondeterministic stuff in your main application language instead; a
borderline case is fetching the current date or time, which is commonly
done close to a database for timestamps, and it is nondeterministic.
* (Basics.pod) Made several large updates to the "ROUTINES" main pod
section, mostly in its sub-section "Functions, Updaters, and
Procedures", which was also renamed to add "Recipes, "; these updates
focused on adding the "recipe" 4th main routine kind, and reducing the
capabilities of "procedure"; in the "Kinds of Procedures" sub-section,
removed the paragraph for the old definition of "recipe".
* (Basics.pod) Made multiple small updates with respect to
transactions, partly to specify that Muldis D now uses a
multi-versioned concurrency model, and also to say that all
transactions are now serializable. These updates were in the 2 main
pod sections "TRANSACTIONS AND CONCURRENCY" and "ROUTINES". The Muldis
D spec still doesn't go into detail on how the concurrency model works,
but that will come eventually, though no longer a high priority item.
* (Types_Catalog.pod) Updated the catalog type "DataNC" to change its
default value from "sys.cat" to "lex.topic", and that is now the
default value of "LexDataNC" also.
* (Types_Catalog.pod) Renamed the catalog type "MultiUpdStmt"
to "MultiUpdInvoStmt".
* (Types_Catalog.pod, Routines_Catalog.pod) In Types_Catalog.pod,
removed the old "Recipe" catalog type, which was a proper subtype of
"Procedure", and updated the "Procedure" type to remove its "is_recipe"
attribute. Also updated all data types used just in defining procedure
statements to change the declared types of any of their "DataNC"
attributes to "LexDataNC". In Routines_Catalog.pod, changed the "noop"
routine from a recipe to a procedure.
* (Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Added the new routine generator called
"recipe" which now defines the only routines that can see or update
global variables, and they are also atomic. In Types_Catalog.pod,
added the catalog type "Recipe", which is mostly a clone of "Updater"
but for having the 2 extra attributes "[upd|ro]_globals" and for
replacing the 1 "stmt" attribute with the 2 "stmt_part_[upd|rcp]";
supporting that, also added the 2 catalog types "RcpGlobalVarAliasMap"
and "MultiRcpInvoStmt", where the latter is mostly a clone of
"MultiUpdInvoStmt" save for the "updater" attribute being renamed to
"recipe". Also added the 2 catalog types "[|Sys]RecipeSet", and
updated each of the 2 catalog types "System", "Depot" to add a
"recipes" attribute. Also added the 2 catalog types "[A|R]PRecipeNC".
In Routines_Catalog.pod, added the 3 recipes "rcp_invo",
"[create|drop]_recipe". Also added new catalog type
"RcpInvoStmtNodeSet", which is a clone of "UpdInvoStmtNodeSet" but for
one renamed attribute, and updated the "StmtNodeSet" catalog type to
add a "rcp_invo_stmts" attribute.
In all 3 STD.pod, added "Recipe Specification" pod sub-section under
"MATERIAL SPECIFICATION" and added the "recipe" material node kind.
* (Tuple.pod, Relation.pod, PTMD_STD.pod) Moved the 2 functions
"sys.std.Core.Tuple.is[|_not]_member" from Tuple.pod to Relation.pod,
in the process renaming them to
"sys.std.Core.Relation.tuple_is[|_not]_member". Updated the references
to those functions in PTMD_STD.pod to use the new names.
* (PTMD_STD.pod) Updated the 2 pod sub-sections "Simple Commutative
N-adic Infix Reduction Operators" and "Simple Non-symmetric Dyadic
Infix Operators", to remove the 5 alternate syntaxes for relational/set
operators which were spelled "R[+*%-/]"; these were attempts to reuse
math op syntax for relational/set ops as does happen in other projects;
they were deemed not similar enough to the loosely-corresponding math
ops, and so were confusing; and, each of the relational/set ops already
had at least 2 other, better alt syn; the removed were superfluous.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the 2 pod
sub-sections "Simple Non-symmetric Dyadic Infix Operators" and "Order
Comparison Operators", to rename the alternate syntaxes for 14
membership-testing functions so that they read better. The spellings
were changed as follows:
from "[S|B|I][[|!|not-]in|∈|∉]" to "[[|!|not-]in-|∈|∉][s|b|i]",
from "[S|B|I][[|!|not-]has|∋|∌]" to "[s|b|i][-[|!|not-]has|∋|∌]",
from "[[|!|not-]has-|∋|∌]t" to "r[-[|!|not-]has|∋|∌]". The spellings
for the 2 related functions were left unchanged: "[[|!|not-]in-|∈|∉]r".
* (Relation.pod, Set.pod, Bag.pod, Interval.pod) Updated the
also-known-as notes for the 14 membership-testing functions in
correspondence to above-mentioned changes.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the 7 pod
sub-sections "Simple [C|Non-c]ommutative N-adic Infix Reduction
Operators", "Simple [S|Non-s]ymmetric Dyadic Infix Operators", "Simple
Monadic P[re|ost]fix Operators", "Order Comparison Operators", to
rename the alternate syntaxes for 15 math functions, 6 string
functions, and 1 relational function, so that they read better. The
spellings were changed as follows:
from "[I|N][+|*|-|/|^]" to "[i|r][+|*|-|/|^]",
from "I|-|" to "i|-|", from "I||" to "i||", from "I!" to "i!",
from "N|-|" to "r|-|", from "N||" to "r||",
from "[B|T|A]~" to "[b|t|a]~", from "[B|T|A]x" to "[b|t|a]-x",
from "R#" to "r#".
* (Integer.pod, Rational.pod, Blob.pod, Text.pod, Array.pod,
Relation.pod) Updated the also-known-as notes for the 22 functions in
correspondence to above-mentioned changes.
* Updated the TODO file so that now there are only 2 highest-priority
items, which are adding the Ordered/Ordinal mixins, and specifying the
concrete syntax for defining types and routines.
2010-03-27 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.114.0 is released on CPAN as
Muldis-D-0.114.0.tar.gz.
* This release features a rough cut of a refactor of the entire Muldis
D type hierarchy at a fundamental level; this introduces the new
concept of the "low-level type system" over which the previously
existing, and still maintained mostly intact, type system is now an
abstraction. In the new low-level type system, there are exactly 2
"declaration" types, the system-defined "Int" and "List", which are now
the only types that introduce values into the type system; now, *all*
other types, including all user-defined types, are just "enumeration"
types, which reuse values from said 2 types, and are defined just in
terms of either a subset or a union of other types. The "Int" type is
exactly the same as in the previous release, consisting of just atomic
integer values, and is the sole Muldis D atomic type. The "List"
type is the sole Muldis D nonatomic type, each value being a dense
sequence of 0..N elements where each element is an "Int" or a "List".
The fundamental reason for this design, where all values are introduced
into the type system by just system-defined types, is so that Muldis D
can support doing data definition plus data manipulation as a single
atomic operation. This is because there is an effective way to
represent and interpret all Muldis D values in the complete absence of
any user-defined types, so there is no chicken-and-egg problem that
prevents DD+DM from being done together in the general case, where one
needs to have non-mutating definitions of user-defined types in order
to do manipulation of data having those types.
* (PTMD_STD.pod) Fix fossil in docs about whitespace in char str lits.
* (Types_Catalog.pod) Updated the "MountControlSet" catalog type to
add an 8th, boolean attribute "allow_auto_run", which is primarily
intended to provide a measure of security against viruses and other
malware that are using Muldis D databases as a vector, especially where
the malicious code is setup to run automatically as soon as its host
depot is mounted. When you have a depot with a dubious history,
mounting it initially with a false "allow_auto_run" will allow you to
examine the depot for malware without giving the latter any opportunity
to run; moreover, you will be able to clean out a virus infection from
a depot that you otherwise wish to preserve; and then you can remount
the depot with a true "allow_auto_run" once you know it is clean, in
order for benign auto-running code to work.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Interval.pod) Eliminated all
of the triadic order comparison operator syntaxes, whose usage would
look like "1 <= $n < 10", because their support unnecessarily
complicated the grammar and also they were completely redundant with
interval membership-test operators, whose usage would look like "$n in
SPInterval:{1..10}". In all 3 STD.pod, updated the pod sub-section
"Order Comparison Operators" to remove the "triadic_compare_op_invo"
grammar node plus all associated documentation and code examples; then
refactored the remaining grammar to merge the 10 nodes
"dyadic_compare_op", "is_[before|after]_op[|__op_cr_[basic|extended]]",
"interval_membership_op[|__op_cr_[basic|extended]]" into the 3 nodes
"dyadic_compare_op[|__op_cr_[basic|extended]]". Also updated the main
pod section "NESTING PRECEDENCE RULES" to remove the one of the 8
precedence levels that was specific to the removed triadic operators
(so it wouldn't mis-parse as a pair of dyadic operators). In
Interval.pod, updated the also-known-as notes for the 2
"value_is[|_not]_member" to excise mentions of such as "!≤≤".
* (Types.pod, README, Core.pod, Basics.pod, Types_Catalog.pod)
Reordered any lists of core data types or related materials so that the
"Rat" types now always precede the "Blob" and "Text" types rather than
follow them. In Types.pod, moved the pod sub-sections that declare the
3 types "[|NN|P]Rat" so they are now just prior to "Blob", and updated
the "TYPE SUMMARY" section accordingly. In the README file and
Core.pod, moved the reference to Rational.pod upwards to just prior to
Blob.pod. In Basics.pod and Types_Catalog.pod, reordered a few lists
of type names in descriptive paragraphs. No changes were needed in the
3 STD.pod as they already used the desired ordering for value literals.
* (Types.pod, Types_Catalog.pod, Rational.pod, Cast.pod, Temporal.pod)
In a reversal of one aspect of release 0.51.0, removed the annotations
on all of the Muldis D data type definitions, either individually or by
documentation section, that said which of the main 4 type categories
(primitive, structure, enumeration, reference) each type belonged to.
This was because these notes would be superfluous following a subseq
change item where *all* types but exactly 2 became enumeration types.
* (Basics.pod, Types.pod, Types_Catalog.pod) Replaced the prior
concept of a "reference type" (as represented by the "Reference" type)
with the concept of an "external type", which for all practical
purposes was a no-op since the only system defined subtype of
"Reference" was "External". In Types.pod, removed the declaration of
the type "Reference", promoted "External" into its place in the type
graph of "TYPE SUMMARY", and renamed the "GENERIC REFERENCE TYPES" main
pod section to "GENERIC EXTERNAL TYPES". In Basics.pod, updated the
"TYPE SYSTEM" main pod section, and its "Type Identification"
sub-section, to rename the "reference type" concept to "external type",
and moved the paragraph describing this concept downwards from that
main section to that sub-section. In Types_Catalog.pod, updated the
description of the "special_types" attribute of the "System" catalog
type to remove "Reference" from its list.
* (Types_Catalog.pod) Added the 2 new scalar enumeration types
"sys.std.Core.Type.Cat.[|DH]ScalarWP" which serve as maximal types of
all scalar values which have any possreps, meaning all scalar values
except for those of "Int", which is atomic. "ScalarWP" is the
difference type of subtracting "Int" from "Scalar", and "DHScalarWP" is
the intersection type of "ScalarWP" and "DHScalar". These types were
added at the top of the "SIMPLE GENERIC SCALAR TYPES" main pod section.
* (Types.pod, Types_Catalog.pod, Rational.pod, Cast.pod, Temporal.pod,
Spatial.pod) In Types.pod and Types_Catalog.pod, did some major
refactoring of the "TYPE SUMMARY" main pod section, featuring the
splitting of the main type graph into multiple graphs that are easier
to read, some showing different views of the same type relationships.
In Temporal.pod, did a smaller refactoring of its "TYPE SUMMARY". In
all 6 files, updated their "TYPE SUMMARY" to do some basic cleanup,
including the addition of a few instances of "[|DH]ScalarWP", and
including the collective removal of most instances of the "Empty" or
"OVLScalar" type from the graph, those being superfluous; now, "Empty"
and "OVLScalar" only appear in graphs of the files that declare them.
* (Types_Catalog.pod, Basics.pod, Types.pod, Scalar.pod, Array.pod,
PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In a reversal of one aspect of
release 0.61.0, and also of one aspect of release 0.109.0,
converted "String" into a primitive scalar type with no
possreps, which is a dense sequence of integers, rather than it being a
nonscalar subtype of "Array"; this all is just a
refactor, and the semantics of "String" are unchanged. In
Types_Catalog.pod, changed the definition of the "String" type to say
it is now the aforementioned primitive scalar type, and updated the
"TYPE SUMMARY" section accordingly; also merged the main pod section
"SIMPLE GENERIC STRING TYPES" into "SIMPLE GENERIC SCALAR TYPES" with
the declarations of the 4 types "[|B|O|UCP]String" being moved up just
prior to "Name". Also updated the description of the "special_types"
attribute of the "System" catalog type to add "String" to its list. In
Basics.pod, updated a few paragraphs in the "TYPE SYSTEM" main pod
section and its subsections as appropriate for the new status of
"String". In Types.pod, Scalar.pod, and Array.pod, updated a few
description paragraphs likewise. In all 3 STD.pod files, updated the
"Scalar" node kind description and removed a code example from the
"Array" node kind, concerning "String"; also updated the code examples
for "the_floor" to temporarily use a stand-in "String:[...]" syntax,
since an "Array" can't be used anymore; however, the "String" value
literal node that release 0.109.0 removed has not also been restored,
which isn't a problem since a subseq change item adds an alternative.
* (Basics.pod, Types_Catalog.pod, Types.pod) Added the 3 new catalog
types "sys.std.Core.Type.Cat.[List|[S|Nons]ructure", where "List"
contains every type system value that "Int" doesn't, "Structure"
contains every "List" value that is a scalar or nonscalar or external
value, and "Nonstructure" contains every "List" value that "Structure"
doesn't; these were declared in the new main pod section of
Types_Catalog.pod named "LOW-LEVEL STRUCTURE TYPES", added just prior
to "SIMPLE GENERIC SCALAR TYPES". A "List" is a dense sequence of
elements where each element is either an "Int" or a "List". Redefined
the "String" type to be a "List" proper subtype, so each of its integer
elements is now an actual "Int"; it still has no scalar possreps,
though. Redefined the "Tuple" and "Relation" types to be "List" proper
subtypes, such that their attribute lists are now "List" values with
one element per attribute, and their headings or bodies are now
expressed as "List", and a relation body is now a list of lists, and
for nonscalars you can now choose "row-oriented" and "column-oriented"
formats which are logically equivalent. Redefined "ScalarWP" to be a
"List" proper subtype whose explicit elements spell out the "type
name", "possrep name", and "possrep attributes" of a scalar value; the
first 2 are "String" and the last is a "Tuple". Redefined the
"External" type to be a "List" proper subtype, and it is now just
conceptually opaque rather than actually, but its payload format is
still implementation-defined. In both Types.pod and Types_Catalog.pod,
updated the "TYPE SUMMARY" sections to add the 3 new types and to
otherwise reflect the new state of affairs; also updated the
descriptions of these existing 12 types to reflect their additional
natures in light of the low-level type system: "Universal", "Empty",
"[|DH]Scalar", "Tuple", "Relation", "External", "ScalarWP",
"[|B|O|UCP]String". In Types_Catalog.pod, updated the description of
the "special_types" attribute of the "System" catalog type to remove
the 5 types "Scalar", "String", "Tuple", "Relation", "External" from
its list, and add the 1 type "List" to its list, and leaving the 3
types "Universal", "Empty", "Int" unchanged. In Basics.pod, several
major updates in the "TYPE SYSTEM" main pod section plus sub-sections.
Rewrote the main section paragraphs that introduced the 4 main type
categories "primitive", "structure", "reference", "enumeration" so to
replace them with the 2 main categories "declaration" and
"enumeration"; also added a paragraph giving rationale for the new
design. Updated the "Type Identification" sub-section to add the
"nonstructure" 5th category to the alternate 4 main value categories
"scalar", "tuple", "relation", "external". Updated the "Distinction of
Non-Homogeneous Types from Homogeneous Types" sub-section to add a
paragraph specifying that DH types exclude external and and
nonstructure valued attributes. Added new pod sub-section "Low Level
Type System" in "TYPE SYSTEM" that introduces and details the new
"low-level type system" concept, where "Int" are the atoms, "List"
compose those, and all other main types are "List" with particular
formats. A consequence of these changes is that now Muldis D has
values which are neither scalar nor nonscalar nor external, though
users should never really encounter these in practice as all the normal
system-defined routines are closed over scalars and nonscalars.
* (Types_Catalog.pod) Added new catalog type "ListSelExprNodeSet"
which provides a means to select any "List" value at all in terms of a
sequence of elements whose values may all be determined at runtime. It
is completely redundant for selecting tuple and relation values and
scalar values with possreps, but it currently provides the only means
to directly select "List" values that are "String" or external or
nonstructure values, not that any normal users should be doing that.
Also updated the catalog type "ExprNodeSet" to add a 15th attribute
"list_sel_exprs" of the new catalog type.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new pod sub-section
named "Low Level List Selectors" to the end of the main pod section
"COLLECTION VALUE SELECTORS", which declares new literal/selector
syntax specific to generic "List" values; this syntax takes the form of
the new "List" value node kind, which looks exactly like the "Array"
value node kind save for the keyword. The new sub-sections include
several code examples showing how to select scalar and nonscalar values
just in terms of "List". Also updated the definition of the grammar
node "value__the_floor" so that it can only consist of "Int" and "List"
nodes, rather than "Int|Scalar|Tuple|Relation" nodes, since that is the
new minimal syntax for the catalog abstraction level "the_floor". Also
obligatorily updated the code examples for "the_floor" to show how the
same 2x2 relation value is represented just in terms of "List" and
"Int"; the primary difference from all the prior iterations of this
code is that now all type and possrep and attribute names are *also*
expressed as strings of integers like the values, not as characters.
* Updated the TODO file concerning stimulus-response rules and DBMS
command-line parameters. Also updated the TODO file concerning the
combination of related 'catalog' and 'data' into single values that are
binary tuples, where a value effectively defines its own constraints,
and that each "version" of a multi-versioned depot is one, and so using
those, just functions or updaters can do what 'recipe' were needed for.
2010-03-13 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.113.0 is released on CPAN as
Muldis-D-0.113.0.tar.gz.
* (Basics.pod, Types_Catalog.pod) Other minor fixes.
* (Basics.pod, Types_Catalog.pod) Expanded the routine overloading
feature so that multiple virtual routines may be directly implemented
by the same other routine, should this be useful. In Basics.pod,
updated the "Overloading With Virtual Routines" pod sub-section. In
Types_Catalog.pod, updated the "implements" attribute of the 3 catalog
types "Function", "Updater", "Procedure" so it is a Set, not a Maybe.
* (Basics.pod, Integer.pod, Rational.pod) Made a few small terminology
fixes; "modulo" is a name for the "remainder"|"%"|"mod" operation, and
"modulus" is a name for the result of that operation; "modulus" is also
an alternate name for the "abs"/"absolute value" operation; update or
add notes about this where appropriate; in general, just don't use the
word "modulus" at all to save on ambiguity.
* Renamed Bool.pod to Boolean.pod; the entities it declares have
all been renamed to "sys.std.Boolean.\w+" from "sys.std.Bool.\w+".
Any references to these in other files [Core.pod, the README
file, PTMD_STD.pod] were updated accordingly.
* In a reversal of one aspect of release 0.101.0, split up
Universal.pod into itself and new file Ordered.pod; moved the 10
ordered-sensitive functions of Universal.pod into Ordered.pod, renaming
each one from the "Universal." name-space to the "Ordered." name-space.
Any references to these in other files [Core.pod, the README file,
PTMD_STD.pod] were updated accordingly.
* (Types_Catalog.pod, Cast.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)
In Types_Catalog.pod, renamed the catalog type "RatRoundMeth" to
"RoundMeth", and its 7 singleton subtypes likewise. Any references to
these, in the other 4 files, were updated accordingly. In all 3
STD.pod, renamed the "Rational Rounding Method Literals" pod
sub-section to remove "Rational", and renamed the "RatRoundMeth" node
kind to "RoundMeth".
* (Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In
Types_Catalog.pod, refactored the catalog type "RoundMeth" and its
singleton subtypes as follows: Renamed the 2 singletons "ToFloor",
"ToCeiling" to "Down", "Up" respectively. Added 2 new singletons
"HalfToZero", "HalfToInf". And so "RoundMeth" now has 9 values, which
were also reordered, where 8 form a 2x4 table crossing
[always-to,half-to] with [down,up,zero,nearest-infinity], and
"half-even" being (while important) somewhat the odd one out. Any
references to these, in the 3 STD.pod files, were updated accordingly.
* (Types_Catalog.pod) Updated the catalog type "RoundMeth" to change
its default value from "HalfUp" to "HalfEven", since in general that
should be the rounding method most likely to minimize the rounding
error from a sequence of operations that each round, which is
especially useful in contexts where a rounding method is implicit.
Similarly updated the default value of the "RatRoundRule" type.
* (Integer.pod) Updated the 6 functions
"[|maybe_][quotient|remainder|quot_and_rem]" to add a mandatory third
parameter "round_meth", so that the functions' result rounding
semantics, when "divisor" doesn't go into "dividend" evenly, can be
customized by the user, and also make the invoking code more
self-documenting. The reason that "round_meth" is mandatory is that
there are no commonly accepted semantics, either in programming
languages or otherwise, for a normal rounding method to use implicitly,
and so there would be a variety of implicit user expectations, and so
spelling out the method explicitly should prevent any bugs due to false
assumptions. Use "Down" to get the currently-defined semantics of
Perl 6's Int-specific ops ("div", "mod"), or Knuth (according to WP);
use "ToZero" to get the semantics of some other languages. Previously
the exact semantics of these functions was not defined and was left
implicit. Furthermore, updated the description of "remainder" to
specify that it preserves the identity "$x % $y = $x - $y * ($x / $y)";
your choice of "round_meth" has an even more pronounced effect here.
* (Integer.pod) Added Int-specific analogies of some Rat-specific
operators that didn't exist before, where there was no particularly
strong reason for Int to lack ops that Rat has. Added the 3
"sys.std.Core.Integer.\w+" operators "[|maybe_]mean", "mean_of_median";
their semantics follow "quotient", meaning floor rounding. They all
have been given "round_meth" params also, follow "quotient" semantics.
* (PTMD_STD.pod) Loosened the definition of "unspace" a bit so that
the whitespace between its pair of backslashes is now optional, so one
may now use them for visual code alignment more effectively if wanted.
* (PTMD_STD.pod) Made the grammar stricter with regards to several
situations where optional whitespace used to be allowed; in those
situations, whitespace is now prohibited except in the form of an
"unspace": 1. In a "language_name" token preceeding a ":" element
separator. 2. In a generic-context value literal / value node following
a ":" element separator. 3. In any value literal payload following a
";" pair-payload element separator. 4. In a rational number body around
the [/,*,^] element separators. 5. In a name-chain around the "."
chain-element separators. 6. In an "accessor" node around the "."
element separator. 7. In all of the "Simple Postcircumfix Operators"
between the base expression and its postfix portion.
* (PTMD_STD.pod) Made the grammar looser with regards to several
situations where no whitespace used to be allowed, such that "unspace"
is now also allowed there: 1. In a rational number body preceeding a
"." radix point. 2. In a "func_invo" between the routine name and its
argument list.
* More TODO file additions or changes.
2010-03-10 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.112.0 is released on CPAN as
Muldis-D-0.112.0.tar.gz.
* This release features a rough cut of a new major feature of the
Muldis D type system, called "mixin types", which is analogous to the
"roles" of Perl 6, or to the "mixins" or "interfaces" of some other
general purpose languages. The new feature now does, or will in a
near-subsequent release, support multiple kinds of important
functionality that were either previously missing from Muldis D or were
implemented in a less elegant manner. The first new functionality is
that a union type can now be declared in the reverse manner to how it
was previously doable using a "domain type"; a domain type definition
explicitly lists all the other types it ranges over, so it is "closed";
in contrast, a "mixin type" is a union type that ranges over other
types that specify themselves to be part of that union, which the other
types do by "composing" the mixin type, so a mixin type is "open". Any
user-defined type can add itself to the domain of even a system-defined
mixin-type (such as "Numeric"), whereas no type can add itself to the
domain of a system-defined domain-type (such as "Bool"). The second
new functionality is that routines can now be declared virtual and be
associated with a union type, and other functions which are associated
with other types that are subtypes of the union can be declared to
implement that
virtual function; this means that Muldis D now supports "operator
overloading" to a limited extent, that limit being that you can only
overload operators that are explicitly defined to be overloadable; in
any event, a direct invocation of a virtual routine will automatically
dispatch to one of its implementing functions based on the data types
of the "dispatch" routine arguments. Strictly
speaking this feature doesn't require mixin types, but with most of the
likely use cases the union type would be a mixin type and the subtypes
its composers. In a subsequent release, mixins
will support code reuse by way of letting you define type attributes in
a mixin and then all composing types will have those attributes without
having to separately define them; this then means Muldis D will support
an approximation of "specialization by extension". Having "mixin
types" also means that some other tangential design changes can be made
to Muldis D more easily, in subsequent releases. Note that a refactor
of the system type hierarchy to exploit mixins has been postponed to
the next release, so this current release merely adds support for
mixins without actually using them.
* (Basics.pod) Updated 3 parts of the "TYPE SYSTEM" main pod section,
listed here in order of occurrance in the file: 1. Updated the
paragraph that talked about "specialization by extension" so instead of
saying that the latter is unsupported (just "specialization by
constraint"), it now says that "extension" will be supported to some
approximation in the near future. 2. Updated the paragraph introducing
the MST (most specific type) concept to chop out the unnecessary second
half, and updating the remainder to say that Muldis D enforces MSTs
only in the contexts where it is necessary, if any. 3. Added a whole
new large paragraph that introduces and distinguishes the 2 main
methods of defining a type in terms of a type union, "domain types" and
"mixin types"; users can extend the latter but not the former.
* (Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Added the new type generator called "mixin
type" which defines new data types whose values are a union of those
from the one or more other types that specify themselves to be part of
that union. In Types_Catalog.pod, added the catalog type "MixinType"
(with the initial 2 attributes "comment", "default"), and added the 2
catalog types "[|Sys]MixinTypeSet", and updated each of the 2 catalog
types "System", "Depot" to add a "mixin_types" attribute. In
Routines_Catalog.pod, added the 2 recipes "[create|drop]_mixin_type".
In all 3 STD.pod, added "Mixin Type Specification" pod sub-sect under
"MATERIAL SPECIFICATION" and added the "mixin_type" material node kind.
* (Types_Catalog.pod) Updated all 6 catalog types
"[Scalar|Tuple|Relation|Domain|Subset|Mixin]Type" to add a
"composed_mixins" attribute, which is simply a set of type names.
* (Basics.pod) In the "ROUTINES" main pod section, added the new pod
sub-section "Overloading With Virtual Routines" which introduces /
explains how Muldis D supports operator overloading and how users
define overloads through "virtual" and "implementing" routines, and
that every kind of routine (func, updater, proc) is overloadable.
* (Types_Catalog.pod) Updated all 3 catalog types "Function",
"Updater", "Procedure" to add the 2 attributes "dispatch_params" and
"implements", where the former is used to declare that a routine is
virtual / can be overloaded and the latter is used to declare that a
routine implements another one; "dispatch_params" is simply a set of
parameter names, and "implements" is a routine name. Also added the 2
new data types "RP[Updater|Procedure]NC" that are like "RPFunctionNC".
* Renamed DateTime.pod to Temporal.pod; the entities it declares have
all been renamed to "sys.std.Temporal.\w+" from "sys.std.DateTime.\w+".
Any references to these in other files [D.pm, Core.pod, the README
file, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod] were updated accordingly.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Corresponding to the previous
change item, renamed the "date_time" standard syntax extension to
"temporal", and renamed the "DATE-TIME EXTENSION OPAQUE VALUE LITERALS"
main pod section to replace "DATE-TIME" with "TEMPORAL".
* (PTMD_STD.pod) Updated the 2 pod sub-sections "Simple Non-symmetric
Dyadic Infix Operators" and "Order Comparison Operators", to rename the
plain ASCII alternate syntaxes for 16 membership-testing functions
so that they read better. The spellings were changed from
"[|S|B|I][|!|not-][i|h]mem" to "[|S|B|I][|!|not-][in|has]", rspectivly.
* (PTMD_STD.pod) Updated the pod sub-section "Simple Non-symmetric
Dyadic Infix Operators" to rename the alternate syntaxes for 4
functions that test membership of a generic tuple in a generic
relation. The spellings were changed from
"[[|!|not-][in|has]|∈|∉|∋|∌]" to "[[|!|not-][in-r|has-t]|∈r|∉r|∋t|∌t]",
respectively. This change was made to lay groundwork for the next
release where the Set|Bag|Interval-specific versions of these operators
would be combined using operator overloading, and the huffmanization
was re-considered to let those have the shorter/unqualified versions of
"is","has" etc and so the versions for generic tuples and relations,
which can't be combined into the same overloads due to type overlaps,
would get slightly longer names ending in "r" or "t" as appropriate.
* (Tuple.pod, Relation.pod, Set.pod, Bag.pod, Interval.pod) Updated
the also-known-as notes for the 16 membership-testing functions in
correspondence to above-mentioned changes.
* Update the TODO file to rewrite / greatly chop the portion about
mixins/roles, now that we have a clearer picture of what exactly to be
doing, and list the top TODO item priorities in order.
2010-03-05 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.111.0 is released on CPAN as
Muldis-D-0.111.0.tar.gz.
* (PTMD_STD.pod) Updated the "Boolean Literals" pod sub-section to add
a keywords-aliases table as if boolean literals were nullary operators.
* (PTMD_STD.pod) Made large changes to the feature that allowed
segmenting long value literals such as to split them over source code
lines. Now, a new Perl-6-inspired feature called "unspace" is used; an
"unspace" token is a pair of backslashes separated by one or more
whitespace chars (typically a linebreak); you can place an unspace
token anywhere in a stringy or numeric value literal and the Muldis D
parser will strip it out, treating the source characters immediately
before and after the unspace as if they were adjacent. This feature
replaces the use of a token for separating literal segments consisting
of a tilde ("~") char bounded by optional whitespace (typically a
linebreak on one side). For numeric literals, that's the total change;
but for stringy literals, another change is that now there is just one
pair of string delimiters around the entire literal, rather than one
around each literal segment, and so the unspace is contained within the
delimiters rather than being outside it. A further change is that a
"non-value-comment" may now contain unspace inside segments, while
those remain each-segment-is-#-quoted-and-whitespace-separated (a tilde
was never used for non-value-comment, so for those programmers have a
choice of both ways to split lines. Unchanged is identifiers/names can
only be segmented when quoted, not when barewords. So a major benefit
to this change is that now the tilde character is freed up to just have
the mneumonic of being concerned with strings, same as in Perl 6,
rather than also being concerned with stitching long numerics et al.
* (DateTime.pod, Types.pod, Temporal.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod, Types_Catalog.pod, Basics.pod, Core.pod,
README) Demoted all of the TAI temporal types and routines from the
Muldis D language core and consolidated them with all the UTC temporal
types in the Muldis D DateTime Extension. So now the core has no
temporal-concerning entities and all temporal stuff is in the DateTime
extension. This change was done in preparation for a more extensive
refactoring of the group of temporal types to happen in the near
future, and also to make easier some other language updates which will
be applied to the remaining core first. The 2 data types
"sys.std.Core.Type.[Instant|Duration]" were moved from Types.pod to
DateTime.pod, and renamed in the process to
"sys.std.DateTime.Type.TAI[Instant|Duration]". The 7 functions
"sys.std.Core.Temporal.Instant.[[|abs_]diff|later|earlier]",
"sys.std.Core.Temporal.Duration.[abs|sum|diff]" and 1 system-service
"sys.std.Core.Temporal.Instant.fetch_curr_instant" were moved from
Temporal.pod to DateTime.pod, and renamed in the process to
"sys.std.DateTime.TAIInstant.[[|abs_]diff|later|earlier]",
"sys.std.DateTime.TAIDuration.Duration.[abs|sum|diff]",
"sys.std.DateTime.TAIInstant.fetch_curr_instant"; the then-empty
Temporal.pod was subsequently deleted. Further updated DateTime.pod as
follows: 1. Updated its NAME and DESCRIPTION text. 2. Renamed 2 of its
main pod sections from "DATA TYPES FOR UTC-BASED DATES AND TIMES",
"DATA TYPES FOR TEMPORAL ARTIFACTS" to "FUNCTIONS FOR DATE AND TIME
MATH", "FUNCTIONS FOR TEMPORAL MATH" respectively. In all 3 STD.pod,
renamed the 2 value node kinds "Instant","Duration" to
"TAIInstant","TAIDuration", and refactored the grammars to demote those
2 node kinds from the core grammar to the optional "date_time" standard
syntax extension; the pod sub-section "TAI Temporal Literals" was
merged into the pod sub-section "Date and Time Literals", which
reflects the merging of the type/routine defs in the other files; and
so all grammar specific to temporal entities are now in that syntax
extension. Updated Core.pod and the README file to reflect the removal
of Temporal.pod. Other minor updates to Basics.pod, Types.pod,
Types_Catalog.pod to reflect the renaming of the 2 TAI temporal types.
* (PTMD_STD.pod) Other minor updates or fixes.
2010-03-01 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.110.0 is released on CPAN as
Muldis-D-0.110.0.tar.gz.
* (Set.pod) Updated ord-det function "sys.std.Core.Set.Maybe.order" to
add an "is_reverse_order" parameter, which it was lacking, and also
renamed (and reordered) 3 other parameters: "ord_func" ->
"S_ord_func", "reverse_order_of_singles" -> "S_is_reverse_order",
"treat_Nothing_as_max" -> "N_is_after_all_S".
* (Array.pod) Added new ord-det function "sys.std.Core.Array.order",
which provides the canonical means to order 2 Array, or 2 String; it
forms the basis for ordering functions of Blob, Text, NameChain, etc.
* (Cast.pod) Updated the type "PInt2_36" to change its default value
to 10 from 2, to correspond to base-10 being the default base for
numeric literals in the STD dialects when no explicit base is given;
also updated all 4 functions which have a param of that type to make
that param optional, as each one will default to 10 if no arg is given.
* (Types.pod, Types_Catalog.pod) Muldis D now incorporates Unicode
5.2.0 rather than the 5.1.0 version.
* (Tuple.pod, Relation.pod, Set.pod, Routines_Catalog.pod,
PTMD_STD.pod, Changes, TODO) Fixed all misspellings of 'analogous'.
* (Types.pod, Basics.pod, Types_Catalog.pod, Scalar.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) In a reversal of one aspect of release 0.61.0,
brought back the concept of scalar types that have zero possreps and
hence are primitive types; however, now only "Int" is a primitive
scalar type, and all other scalar types including "String" are still
not; also removed the cludge concept of a type being defined as a union
over an infinite number of singleton types, which "Int" had used but no
longer does; this all is just a refactor, and the semantics of "Int"
are unchanged. In Types.pod, changed the definition of the "Int" type
to say it is now an infinite-cardinality primitive type with no
possreps rather than say it is an enumerated type over an infinite
number of singleton "Int.*" types, and also deleted said infinite
"Int.*" types. In Basics.pod, updated a few paragraphs in the "TYPE
SYSTEM" main pod section or its subsections so they now say that "Int"
is the third primitive type (besides "Tuple" and "Relation"), and added
mentions that the special "Int" can have no possreps, and removed any
references to the "Int.*" types. In Types_Catalog.pod and Scalar.pod,
updated a few description paragraphs likewise. In all 3 STD.pod files,
updated the "Scalar" expression node kind to specify it can't any more
be used to select "Int" values, but just all other scalar values, and
updated the "the_floor" catalog abstraction level to also allow use of
"Int" as a "value" node in addition to the 3 "Scalar", "Tuple",
"Relation" of before; also updated any example Muldis D code that had
used a "Scalar" node to select an "Int" value to use an "Int" node
instead; this example code was all in the "the_floor" pod sub-section,
which was made an order of magnitude less verbose as a result.
* (PTMD_STD.pod, HDMD_Perl5_STD.pod) Small amount of grammar
normalization where any non-alphanumeric grammar characters intended to
be matched literally are now written string-quoted rather than
backslashed; for example, [\^] was changed to ['^']; all of the changes
concerned the formats of integer or rational value literals.
* (PTMD_STD.pod) Made the "if_else_expr" grammar node kind stricter
such that a minimum of 1 "if_expr"+"then_expr" element is needed rather
than zero being allowed. But the corresponding system catalog values
and Perl-STD grammar nodes still allow zero elements.
* (PTMD_STD.pod) The grammar now uses "<ws>" and "<ws>?" rather than
"\s+" and "\s*" to define whitespace rules of Muldis D code, and
moreover the meaning of "<ws>" is defined by Muldis D rather than using
Perl 6's definition, such that our "<ws>" has a stricter definition
that just includes the 5 ASCII characters SPACE and [\t\n\f\r]. This
means that, for now, Unicode linebreaks and other kinds of whitespace
aren't allowed literally outside of character string literals.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, D.pm) Refactored the grammar
for the 2 fully-qualified Muldis D language name elements
"ln_base_authority", "ln_base_version_number" so that they are no
longer defined as having the same format as a "Name" payload, but
rather they are independently defined, so they can evolve separately.
Now these 2 "ln" parts (and hence all language-name parts) are more
strict in that they must be nonempty strings and they are expressly
limited to using non-control characters in the ASCII repertoire,
instead of being allowed any Unicode chars. But in PTMD_STD, the
bareword format of the 2 parts now has fewer limitations than a
bareword "Name", in that it may have periods and it may start with
digits; therefore, updated all example code of Muldis D language names
so that the version-number portion is no longer delimited.
* (PTMD_STD.pod) Made the nonquoted "Name" literals format more
restrictive so it only allows ASCII chars, and not anything else that
Unicode considers an alphanumeric. Technically speaking, the actual
grammar is unchanged, but rather the associated documentation saying it
should be expanded to include Unicode alphanums was removed/replaced.
* (PTMD_STD.pod) Updated the 2 pod sub-sections "Simple Non-symmetric
Dyadic Infix Operators" and "Order Comparison Operators", concerning
the existing alternate syntaxes for 24 functions that test set
membership or sub/superset relationships, so that plain ASCII infix
syntax alternatives are now provided, and not just infix syntax options
that use trans-ASCII Unicode characters. All of the additional options
are alpha rather than symbolic, such as "imem" for "∈". As a result of
this update, now one can use all features of the 3 STD dialects without
touching any non-ASCII Unicode characters, besides the Unicode support.
Also, for the 2 operators "I∈" and "I∉", added the additional aliases
"between" and "!between"|"not-between", respectively.
* (Tuple.pod, Relation.pod, Set.pod, Bag.pod, Interval.pod) Updated
the also-known-as notes for 24 functions in correspondence to
above-mentioned changes.
* (PTMD_STD.pod) Fixed 3 instances of a grammar typo.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new mandatory pragma
"op_char_repertoire" that determines whether or not the various routine
invocation alternate syntaxes (and a few special value literals) may be
composed of only ASCII characters or also other Unicode characters.
Code specifying "basic" for the new pragma can only use ASCII chars
outside delimited character strings and should work on minimal Muldis D
implementations and older text editors, while code specifying
"extended" can use all the defined canonical symbols for math or logic
or relational et al operations as recognized in the wider world, rather
than just approximations. Updated the main pod section "LANGUAGE NAME"
and added the new main pod section "OPERATOR CHARACTER REPERTOIRE"
(located just following "CATALOG ABSTRACTION LEVELS"). Updated all
code examples with a "language name" to add uses of the new pragma. In
PTMD_STD.pod, each of the 2 op char repertoires has its own definition
for the 9 grammar nodes "Bool_payload", "maybe_Nothing",
"comm_infix_reduce_op", "[|non]sym_dyadic_infix_op",
"monadic_prefix_op", "is_[before|after]_op", "interval_membership_op";
this is the semi-formal way in which the effects of each level on the
grammar are specified. In the various pod sub-sections of PTMD_STD.pod
that declare said 9 (now refactored / split in 2) grammar nodes,
reorganized the various doc tables (saying what keywords are aliases or
what functions they invoke) so that ASCII versions are now consistently
favored over other Unicode versions as the "main" versions, rather than
sometimes ASCII and sometimes Unicode; but, where 3 or more versions of
the same operator exist, a Unicode version is always in 2nd place and
favored over all but the single main ASCII version; all code examples
in these sub-sections were left unchanged, some using Unicode.
* Update TODO file with draft outline on some grammar/etc changes that
would add support for different charsets in delimited char strings,
especially Unicode compatibility vs canonical, which when used for
identifiers could help avoid some security problems.
2010-01-26 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.109.0 is released on CPAN as
Muldis-D-0.109.0.tar.gz.
* This release features a refactor of the root of the scalar type
composition hierarchy so that now how it is actually structured is a
better reflection of how it was conceptually structured before. To be
specific, "Int" replaces "String" as that 1 special type which is
defined as an enumeration union type over an infinite number of
singleton types. "String" was conceptually a dense sequence of "Int"
and now it actually is one; "String" is now nonscalar, an
"array_of.Int", and "Int" no longer has a possrep defined over a
single-element-"String"-typed attribute. One of the many benefits of
this change is that we will no longer need to add a bunch of
"String"-specific functions to bootstrap the system scalar type
definitions; we can now just use the Int or Array functions instead.
* (Types.pod) Refactored the "Int" type by splitting that into itself
plus an infinite number of "Int.*" singleton types, where the former is
defined as a union over the latter.
* (Types_Catalog.pod) Refactored the infinite scalar "String[|.*]"
types by merging them into the single nonscalar "String" type which is
defined simply as a proper subtype of "DHArray" with "Int" elements.
Also deleted the "SEString" subtype which has no more uses now that
"Int" isn't defined over "String". The other 3 subtypes
"[B|O|UCP]String" still exist and are unchanged from before aside from
becoming "Array" subtypes as with "String"; all scalar types besides
"Int" that composed a "String" subtype still do, meaning "Blob" and
"Text". Split the main pod section "SIMPLE GENERIC SCALAR TYPES" into
itself plus the new main pod section "SIMPLE GENERIC STRING TYPES"; the
latter got all 4 of the "String" types (that are no longer scalar) and
the former kept all the other types. Also updated the def of the
"OVLScalar" union type to exclude "String", which is no longer scalar.
* (Basics.pod, Types_Catalog.pod) Updated the few references that said
"String" was special and changed them to say "Int" instead, and
otherwise updated any references to those 2 types as appropriate.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Completely removed the value
literal syntax specific to the "String" type (that being the "String"
value node kind), and the whole "Low Level Integer String Literals" pod
sub-section along with it. If one still has a reason to write plain
"String" literals that aren't by way of the "Blob" or "Text" syntax,
then an ordinary "Array" literal with "Int" elements is typically just
as concise as the old "String" literals were. Also updated all code
examples, that had used nestings of the generic "Scalar" value literal
syntax to select "Int" or "Text" values in terms of the singleton
"String" types, to instead either use the new "Int" singletons straight
out or use those with "Array" or "Relation" literals to select the
"Text". These examples were all in 2 places, the "Scalar Selectors"
pod sub-section and especially the "the_floor" pod sub-section.
* (PTMD_STD.pod) In the "General Purpose Integer Numeric Literals" pod
sub-section, cleaned the grammar to remove unnecessary square brackets.
2010-01-24 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.108.0 is released on CPAN as
Muldis-D-0.108.0.tar.gz.
* (Basics.pod, Types_Catalog.pod) This release features a significant
change to how explicit (not as-an-updater) transactions are defined and
conceived. Before, an explicit transaction was tied to a "try-catch"
control-flow statement and the transaction encompassed the procedure
invoked as the "try", and the same procedure could also be invoked
non-transactionally (outside a "try-catch"). Now, an explicit
transaction is instead tied to a procedure definition itself, meaning
that all invocations of that procedure, whether through a "try-catch"
or not, are now transactional. This change means that all (lexically
scoped) transactions are now be treated the same, as being attached
just to the definition of the routine whose actions they compose, and
an invoker doesn't have to invoke an updater or procedure differently
in that respect to make it a transaction. Now, a "try" is only used as
with traditional languages, in that it just catches exceptions and it
doesn't define transaction scopes. All this being said, the other
fundamentals for transactions in Muldis D are unchanged; terminating a
routine abnormally with a thrown exception is the *only* way to make a
transaction associated with the routine's scope to rollback; it commits
otherwise. In Basics.pod, updated the "TRANSACTIONS AND CONCURRENCY"
main pod section and the "Functions, Updaters, and Procedures" pod
sub-section of "ROUTINES". In Types_Catalog.pod, updated the
"Procedure" catalog type to add a 9th attribute "is_transaction"; also
updated the description of the "try" attribute of the
"TryCatchStmtNodeSet" catalog type.
* (Integer.pod, PTMD_STD.pod) Renamed the 2 functions
"sys.std.Core.Integer.[in|de]c" to "succ|pred" (succeeding|preceding).
* (PTMD_STD.pod) Typo fix.
* Update TODO file with draft outline on some type system changes that
would add mixins/interfaces/etc, and for some transaction handling
changes that make a DBMS multi-versioned fundamentally.
2010-01-16 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.107.0 is released on CPAN as
Muldis-D-0.107.0.tar.gz.
* This release features a change in the canonical way to represent the
kind of data types that would conventionally be called "enumerated
types" in the industry, where examples are the system-defined types
"Bool", "Order", "RatRoundMeth". The old canonical way was for each
"enumerated type" to be a scalar structure type with a single main/only
possrep with a single "Name"-typed attribute whose allowed values are
restricted to a pre-defined set. The new canonical way is for each
"enumerated type" to be declared as a scalar union type over a set of
singleton scalar types (each with a single possrep with zero
attributes), with one singleton type per pre-defined value.
* (Types.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod,
Basics.pod, Conventions.pod, Array.pod, Bag.pod,
Blob.pod, Bool.pod, Interval.pod, Relation.pod, Routines_Catalog.pod,
STDIO.pod, Scalar.pod, Set.pod, Text.pod, Tuple.pod, Universal.pod,
Counted.pod, DateTime.pod) Renamed all of the "simple enumeration"
structure data type values, and the other named singleton values, so
that their words are capitalized rather than lowercase, and lack
underscore separators where they had them before. Both the applicable
scalar attribute values, and the literal-keywords in all dialects, were
updated. These 12 scalar values/keywords are the result of said
renaming: "Bool:[False|True]", "Order:[Increase|Same|Decrease]",
"RatRoundRule:[Half[Down|Up|Even]|To[Floor|Ceiling|Zero|Inf]". These 4
nonscalar values/keywords are the result of said renaming: "Tuple:D0",
"Relation:D0C[0|1]", "Maybe:Nothing". The relevant type definition
updates were in Types.pod (Bool) and Types_Catalog.pod (Order,
RatRoundRule). The relevant literal-keyword updates were in all 3
STD.pod, and to a lesser extent in Types.pod and Basics.pod. In a few
places there were capitalization changes to some routine names or
routine parameter names, concerning the 4 nonscalar values. All other
files updated in this change item are mainly referential updates.
* (Types_Catalog.pod) Updated the catalog type "DomainType" to add an
optional-use 8th attribute "order" which functions as per that
attribute of "ScalarType"; this is intended to support enum types that
are defined as a union of singletons to have a built-in values order.
* (Types.pod, Types_Catalog.pod, Basics.pod, PTMD_STD.pod) In
Types.pod, refactored the 1 type "Bool" into 3 types which are itself
plus the 2 "Bool.True", "Bool.False" where the latter 2 are singleton
types and the former is defined as a union over them. In
Types_Catalog.pod, likewise refactored the 2 types "Order" and
"RatRoundMeth" into 4 types and 8 types, respectively. In Basics.pod,
in the "TYPE SYSTEM" main pod section, brought up to date any
references to whether the 3 refactored types are are considered
structure or enumerated types. In PTMD_STD.pod, updated the
descriptions of the 3 node kinds "Bool", "Order", "RatRoundMeth" to
remain compatible with refactor about how payloads map to values.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the "Interval
Selectors" pod sub-section to add special shorthand syntax for
singleton (single-value) interval-parts, so that the identical
endpoints can be specified once (eg, "{6}") rather than twice (eg,
{6..6}). This feature was previously in release 0.105.0 for PTMD_STD
only, but removed in 0.106.0; now this feature's in all 3 STD dialects.
2010-01-07 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.106.0 is released on CPAN as
Muldis-D-0.106.0.tar.gz.
* This release features a re-do of release 0.105.0 with respect to just
the changes it made concerning interval types; all other aspects of the
language spec are untouched. The primary change items of release
0.106.0 are in 2 groups, the first group which restores the state of
intervals to that of release 0.104.0, and the second group re-adds
support for multiple-part unions in a different manner.
* (Types.pod) Updated the descriptions of the 3 types
"DH[Set|Array|Bag].T" to specify that they are intersection types.
* (Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Basics.pod,
Types.pod, Universal.pod, Relation.pod, Interval.pod) Fixed several
instances of typos where "a" should be "an" or vice-versa.
* (Interval.pod) Updated the "NAME" pod to say "Muldis D generic
interval operators" rather than "Muldis D Interval specific operators"
and updated the "DESCRIPTION" pod similarly.
* (Universal.pod) Corrected a fossil, left over from the changes in
version 0.101.0, where the paragraph talking about intervals should
never have been copied from Ordered.pod to Universal.pod, since the
functions it described went to Interval.pod instead.
* (Types.pod, Basics.pod, Types_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) This change item reverts all the material
interval-concerning changes of release 0.105.0 so that that subsequent
change items can re-add those changes in a different manner. In
Types.pod, removed the 2 core relation types "[|DH]IntervalUnion". In
Basics.pod, updated the "Referencing Data Types" pod sub-section so it
is once again implied that the "[|dh_]interval_of" prefix declares
"Interval" types as in 0.104.0; also updated the "NOTES ON TERMINOLOGY"
main pod section to remove the glossary item "interval, interval-union,
non-union interval". In Types_Catalog.pod, updated the
"IvlSelExprNodeSet" catalog type to rename its "elems" attribute to
"interval", and otherwise reverted its description. In all 3 STD.pod,
updated the "Interval Selectors" pod sub-section to revert all of its
details to release-0.104.0-state, including that "Interval" nodes now
select "Interval" values again, and removed its newest 3 code examples.
In PTMD_STD.pod, removed the shorthand for single-elem interval values;
this specific feature is *not* being brought back as part of the re-do.
Following these reversions, all Muldis D routines, types, syntax that
uses intervals now again uses exclusively "Interval" or its subtypes.
* (Types.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod,
Basics.pod, Interval.pod, Array.pod, Relation.pod, Integer.pod,
Rational.pod) Renamed the plain "interval" concept to the more
descriptive "single-piece interval", which affects several areas of the
Muldis D syntax but has no impact on its semantics. In Types.pod,
renamed the 2 core types "[|DH]Interval" to "[|DH]SPInterval". In
Types_Catalog.pod, renamed the catalog type "IvlSelExprNodeSet" to
"SPIvlSelExprNodeSet", and updated the catalog type "ExprNodeSet" to
rename its "ivl_sel_exprs" attribute to "sp_ivl_sel_exprs". In all 3
STD.pod, renamed the "Interval" value node kind to "SPInterval". In
Basics.pod, updated the "Referencing Data Types" pod sub-section to
rename the prefix "[|dh_]interval_of" to "[|dh_]sp_interval_of". In
all relevant files, updated any references to the old names to instead
use the new names.
* (Types.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod,
Basics.pod) Expanded the generic parameterizable interval types core
feature so that multi-piece intervals (such as {1..3,6..6,8..9}) are
supported, not just single-piece intervals (such as {1..10}). In
Types.pod, added the 2 new core types "[|DH]MPInterval" which are
relation types defined partly in terms of the 2 tuple types
"[|DH]SPInterval", where they have the same nonscalar headings, and add
no constraints; also, the canonical empty interval value is now the
relation with zero tuples rather than a single tuple with min before
max. In Types_Catalog.pod, added new catalog type
"MPIvlSelExprNodeSet" that corresponds directly to
"SPIvlSelExprNodeSet" (it selects multi-piece rather than single-piece
intervals) but its payload attribute is named "elems" (such as the
set|ary|bag-sel types have) rather than "interval". Also updated the
catalog type "ExprNodeSet" to add a 14th attribute "mp_ivl_sel_exprs"
of the new catalog type. In all 3 STD.pod, updated primarily the
"Interval Selectors" pod sub-section to added new value node kind
"MPInterval", which is similar to "SPInterval" but that takes a list of
interval specifiers rather than exactly one. Also added 3 "MPInterval"
code examples to each STD file under "Interval Selectors". In
Basics.pod, updated the "Referencing Data Types" pod sub-section to add
the prefix "[|dh_]mp_interval_of". For now all of this new multi-piece
intervals support is just declared and can be used by users, but no
other parts of the language itself use the features yet.
2010-01-03 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.105.0 is released on CPAN as
Muldis-D-0.105.0.tar.gz.
* This release features some significant changes to the way that
nonscalar types are declared and referenced. Previously, the only
facility to declare a nonscalar type mainly in terms of an attribute
list, as a "NonscalarType" material, was limited in that it could only
declare 2 new data types at once, a tuple type and relation type with
matching headings, rather than just 1 of those. In order to reference
either of the 2 data types individually, it was generally required to
use a "type.tuple_from." or "type.relation_from." prefix in the
reference; if the material was referenced without either prefix as a
type, then it was either the tuple type or relation type referenced,
depending on how the material was defined. This whole state of affairs
tended to make some things more complicated than they ought to have
been, even if it was meant to prevent some other complications; but
thanks to groundwork laid by some previous releases, this situation has
now been reversed as the alternate state of affairs is no longer so
troublesome. And so now, the "NonscalarType" material kind has been
split up into the 2 new material kinds "TupleType" and "RelationType",
where each one declares exactly 1 data type as is otherwise normal, and
the "from" prefixes no longer exist in their prior forms. Following
the refactor, to declare a tuple type it is done simply as one might
expect. But to declare a relation type, it is now mandatory to also
explicitly declare a tuple type over which the relation type is partly
directly defined. A tuple type declaration specifies the nonscalar
heading and the per-each-tuple constraints (plus other details), while
a relation type declaration adds per-whole-relation constraints and
(unique) key constraints.
* (Types_Catalog.pod) Split the 1 "NonscalarType" catalog type, which
had 13 attributes, into the 2 "[Tuple|Relation]Type", which have 9 and
6 attributes respectively. Both of the new types got a copy of these 2
old attrs: "comment", "base_type". The 1 old attr "is_tuple_first" is
simply gone, and just "RelationType" has the 1 new attr "tuple_type".
Only "TupleType" has a copy of these 7 attrs: "attrs",
"virtual_attr_maps", "tuple_constraints" (renamed to "constraints"),
"distrib_keys", "[|distrib_]subset_constraints", "default_tuple"
(renamed to "default"). Only "RelationType" has a copy of these 3
attrs: "relation_constraints" (renamed to "constraints"), "keys",
"default_relation" (renamed to "default"). Also split the 2 catalog
types "[|Sys]NonscalarTypeSet" into the 4
"[|Sys][Tuple|Relation]TypeSet" where each new one is a clone of its
original save for its name. Also updated each of the 2 catalog types
"System", "Depot" to split its "nonscalar_types" attribute into the 2
"[tuple|relation]_types".
* (Routines_Catalog.pod) Split the 2 catalog recipes
"[create|drop]_nonscalar_type" into the 4 recipes
"[create|drop]_[tuple|relation]_type".
* (Types.pod, Types_Catalog.pod) In Types.pod, added the 6 new tuple
types "sys.std.Core.Type.[|DH][Set|Array|Bag].T", each of which exists
in order for the corresponding-named relation type to be defined partly
in terms of it. In Types_Catalog.pod, updated the "DESCRIPTION" main
pod section to add a note that for every relation type defined in that
file there is also a corresponding tuple type, but those tuple types
are not yet explicitly defined (its TODO later).
* (Basics.pod, PTMD_STD.pod) In Basics.pod, updated the "Referencing
Data Types" pod sub-section of "ENTITY NAMES" to remove any references
to the "[|dh_]relation_from." prefixes, leaving only the
"[|dh_]tuple_from." prefixes, and rewrote the associated rationale
text. In PTMD_STD.pod, updated one sentence of the "DBMS Entity Name
Literals" pod sub-section concerning the same thing.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Split the "Nonscalar Type
Specification" placeholder pod sub-section into the 2 "[Tuple|Relation]
Type Specification" and split the "nonscalar_type" material node kind
into the 2 "[tuple|relation]_type".
* (Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Renamed the type generator called "union type"
to "domain type" so to better describe what the generator actually
does; it can define types not only as type unions but also type
intersections|differences|etc. In Types_Catalog.pod, renamed the
catalog type "UnionType" to "DomainType", and renamed the 2 catalog
types "[|Sys]UnionTypeSet" to "[|Sys]DomainTypeSet", and updated each
of the 2 catalog types "System", "Depot" to rename its "union_types"
attribute to "domain_types". In Routines_Catalog.pod, renamed the 2
recipes "[create|drop]_union_type" to "[create|drop]_domain_type". In
all 3 STD.pod, renamed the "Union Type Specification" pod sub-section
to "Domain Type Specification" and renamed the "union_type" material
node kind to "domain_type".
* (Types.pod) Fix indenting under "TYPE SUMMARY"; the "Interval" type
is a "Tuple" not a "DHTuple".
* (Types_Catalog.pod) Corrected several instances of a fossil, left
over from the changes in version 0.90.0, where uses of the term
"declared name" should have been changed to "invocation name". Also
corrected several instances of a fossil, left over from the changes in
version 0.81.0, where uses of the phrase "type whose declaration it is
part of" should have been changed to "type being defined".
* (Types_Catalog.pod, HDMD_Perl[6|5]_STD.pod) Fixed several instances
of fossil-typos where "a" should be "an" or vice-versa.
* (HDMD_Perl6_STD.pod) Modified a few code examples to use more of the
":foo<bar>" Perl 6 syntax rather than ":foo('bar')" where it works.
* (PTMD_STD.pod) Updated the "DBMS Entity Name Literals" pod
sub-section regarding abbreviated references to system-defined entities
so to clarify that any trailing empty-string chain elements of the
entity names are ignored when determining a match for an abbreviated
reference; the behaviour is similar to how fully-qualified references
don't need trailing empty-string chain elements either.
* (Conventions.pod) Added a couple paragraphs to the "Entity Naming"
pod sub-section concerning relative naming of tuple and relation types.
* (Types.pod, Basics.pod, Types_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Expanded the generic parameterizable interval
types core feature so that interval-unions (such as {1..3,6..6,8..9})
are supported, not just (non-union) intervals (such as {1..10}). In
Types.pod, added the 2 new core types "[|DH]IntervalUnion" which are
relation types defined partly in terms of the 2 tuple types
"[|DH]Interval", where they have the same nonscalar headings, and add
no constraints; also, the canonical empty interval-union value is now
the relation with zero tuples rather than a single tuple with min
before max. In Basics.pod, updated the "Referencing Data Types" pod
sub-section to declare that the "[|dh_]interval_of" prefix now actually
declares interval-union types, not (non-union) intervals as before.
Also updated the "NOTES ON TERMINOLOGY" main pod section to add the
glossary item "interval, interval-union, non-union interval" which
explains how now the unqualified term "interval" may actually mean
"interval-union". In Types_Catalog.pod, updated the
"IvlSelExprNodeSet" catalog type to rename its "interval" attribute to
"elems", such as the set|ary|bag-sel types have, and update its
description to specify it selects interval-unions. In all 3 STD.pod,
updated the "Interval Selectors" pod sub-section to specify that
"Interval" nodes now select "IntervalUnion" values rather than
"Interval" values, and to expand what literal formats an "Interval"
node payload may be; generally the new payload format is a list each of
whose elements is what the old payload was; but for the most part a
whole payload may alternately be just what an element would otherwise
be, which maintains backwards compatibility with old Muldis D code. To
be specific, both PTMD_STD and HDMD_Perl6_STD have complete backwards
compatibility while HDMD_Perl5_STD has backwards compatibility only
where the old "min" or "max" expression node values weren't expressed
as Perl array refs, such as would be the case with temporal intervals
but not generally with numbers or text. Also added 3 more code
examples to each STD file under "Interval Selectors".
* (PTMD_STD.pod) Added special shorthand syntax for non-union
intervals, that consisted of a single value, of interval-union
literals, so that the single non-union interval's value could be
specified once (eg, "{6}") rather than twice (eg, {6..6}).
* Incremented all copyright year range-ends to 2010.
2009-12-26 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.104.0 is released on CPAN as
Muldis-D-0.104.0.tar.gz.
* (Routines_Catalog.pod) Fixed a few search+replace errors that
release 0.96.1 introduced.
* (PTMD_STD.pod) Corrected a few pod formatting errors.
* (Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Refactored the name-chain catalog types and
their corresponding literal syntax, to make some design simplifications
while maintaining the existing level of functionality. In
Types_Catalog.pod, renamed the "NameChain" type to "PNSQNameChain"
(parent namespace qualified) and the "DeclNameChain" type to
"NameChain", and then merged the 2 types to make the new
"PNSQNameChain" a proper subtype of the new "NameChain" rather than a
disjoint type, and "PNSQNameChain" now has a different default value;
the 2 types' definitions are otherwise unchanged. In all 5 files,
updated any references to these types to use their new names. In
Types_Catalog.pod, renamed the "NameDNCMap" type to "NameNCMap" and
renamed its "dnc" attribute to "nc"; also updated any refs to use the
new names. In all 3 STD files, renamed the "NameChain" node kind to
"PNSQNameChain" and the "DeclNameChain" node kind to "NameChain"; now,
both node kinds can be used as literals for "NameChain" values, and
they mainly differ in that the new "PNSQNameChain" supports all the
various special shorthands for name chains while the new "NameChain"
supports no shorthands at all. The end result of these changes for
writing Muldis D code is that GCVLs denoting name-chain values have
changes to their "node kind" while SCVLs (most uses) have no changes.
* (Basics.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)
In Basics.pod, updated the "ENTITY NAMES" main pod section and its
"User-Defined Entities" subsection to add the new primary namespace
"rtn", which refers to the lexically innermost routine, and its use
should make it easier to write directly-recursive routines, especially
routines that are written as anonymous routines, where the name of that
routine is chosen automatically by the compiler rather than explicitly
by the programmer. In Types_Catalog.pod, updated the catalog type
"PNSQNameChain" and its appropriate subtypes to include the "rtn"
chain; also updated the desc of the "namespaces" attr of the "System"
catalog type to add "rtn". In PTMD_STD.pod, added refs to "rtn" in the
"PNSQNameChain" node kind desc. In all 3 STD files, added a code
example of invoking a function using its "rtn" name-alias.
* Updated the TODO file with the broad criteria for moving the dev
status of the Muldis D spec from its current "pre-alpha" to "alpha",
and broad further criteria for moving it to "beta" or above.
2009-12-20 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.103.0 is released on CPAN as
Muldis-D-0.103.0.tar.gz.
* (Types_Catalog.pod) A procedure may now directly invoke a function,
rather than needing the contrivance of an updater intermediary when it
conceptually wants to do this. However, a procedure still may not
directly have any expression trees; a procedure's function invocation
is directly bound to a list of variables, for the function's arguments
to come directly from its or result to go directly to. An interesting
consequence of this change is that now users may write a large amount
of their Muldis D code procedurally rather than functionally (not that
this is generally a good idea), where each function invocation that
they do have is sequenced in time between the others, except that they
still need functions when invoking system-defined routines that take
functions as arguments, not that those always need to be used. Added
new catalog type "FuncInvoStmtNodeSet", and updated the catalog type
"StmtNodeSet" to add a new attribute "func_invo_stmts" of the new type.
Also updated the descriptions of the "OVLScaValStmtNodeSet" and
"APMaterialNCSelStmtNodeSet" catalog types. Also fixed a few fossils
where the "IISArgVarMap" type is used.
* (Types_Catalog.pod, Routines_Catalog.pod, Basics.pod,
Conventions.pod) Converted the try-catch control flow construct from a
generic procedure to its own procedure statement kind. This was done
partly to support the language being simplified in other ways, such as
to remove features that weren't really being used except by the old
"try_catch" procedure. In Types_Catalog.pod, added new catalog type
"TryCatchStmtNodeSet", and updated the catalog type "StmtNodeSet" to
add a new attribute "try_catch_stmts" of the new type. In
Routines_Catalog.pod, removed the "try_catch" procedure. In
Basics.pod, changed any references to the removed procedure to refer to
the new statement kind. In Conventions.pod, a small related change.
* (Basics.pod) Rewrote or otherwise reorganized about 2/3 of the
"ROUTINES" main pod section (including all its sub-sections) to bring
it more up to date, make it easier to understand, and to add more
information. Rather than having a separate pod sub-section for each
routine kind, the information on the kinds is spread out over multiple
sections that organize more on feature topics, or separate fundamentals
from special cases. The "ROUTINES" main description plus the 4
sub-sections "function", "updater", "procedure", "Other Matters" were
about 90% rewritten as a new main description plus the 3 sub-sections
"Functions, Updaters, and Procedures", "Emphasis on Purity", "More on
Parameters". The 10 sub-sections "[type|state|transition]-constraint",
"named-value", "[possrep|virtual-attr]-map", "order-determination",
"value-filter", "value-map", "value-reduction" were reorganized and
about 20% rewritten into the 2 sub-sections "Kinds of Functions by
Structure", "[Constraint|Other] Function Kinds by Purpose"; in the
process, also added the 2 new function kinds "value-map-unary",
"value-constraint", which serve to organize some of the other special
kinds; "value-constraint" names the structure that
"[type|state]-constraint" both have, and "value-map-unary" does that
for both of "[possrep|virtual-attr]-map"; it was also formalized that
"value-filter" is a (more specialized) "value-map". The 1 sub-section
"system-service" was renamed and 10% rewritten into the 1 sub-section
"Kinds of Procedures"; in the process, redefined one nature of
"system-service" so that now it *is* a procedure rather than being a
4th main kind of routine (not one of func|upd|proc); this also now
means that users can define "system-service" routines too, rather than
those being restricted for being built-ins. For all intents and
purposes, this change item made no material change to the Muldis D
language, but simply reorganized how the existing design is explained.
* (Basics.pod, Routines_Catalog.pod) In Basics.pod, added a new
procedure kind named "recipe" which is restricted to be deterministic
and is automatically a serialized-isolation transaction; it is intended
mainly for defining routines that conceptually do both data-definition
and data-manipulation as an atomic unit, since those two actions can't
actually happen simultaneously. In Routines_Catalog.pod, updated all
of the routine signatures that used to be "procedure", except for the 1
"proc_invo", so they are now "recipe" instead.
* (Types_Catalog.pod, Basics.pod) In Types_Catalog.pod, added 8 new
catalog types that are all proper subtypes of "Function":
"[NamedVal|ValMap[|U]|ValFilt|[Val|Trans]Constr|ValRed|OrdDet]Func";
each of these corresponds to one of the 8 similary-named function kinds
named in Basics.pod that can be easily distinguished by its structure
(number or names of function parameters or function result declared
types). Also reordered the "CurriedFuncNC" subtype declarations so
they match the order of the new catalog types they correspond to. In
Basics.pod, updated the "Kinds of Functions by Structure" pod
sub-section to add references to the 8 new catalog types.
* (Types_Catalog.pod, Basics.pod) In Types_Catalog.pod, updated the
catalog type "Procedure" to add the 2 new boolean attributes
"is_recipe", "is_system_service"; when one is true (they default to
false) then the procedure is explicitly declared to be that kind of
procedure. Also added 2 new catalog types that are all proper subtypes
of "Procedure": "Recipe", "SystemService"; each of these corresponds to
one of the 2 similary-named procedure kinds named in Basics.pod. In
Basics.pod, updated the "Kinds of Procedures" pod sub-section to add
references to the 2 new catalog types.
* (PTMD_STD.pod) In the "Material Specification Common Elements" pod
sub-section, updated the "material_kind" node kind to replace the 10
old named function kinds with the 8 new ones distinguishable by
structure, and added the 2 named procedure kinds.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the DESCRIPTION main
pod section to use the current Muldis D version number in the
fully-qualified name of the dialect rather than "N.N.N", and updated
all code examples that declare a language name to use the current
version rather than "1.2.3". If there is still a good reason to do
differently than this, these changes might be reverted in the future.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new pragma
"standard_syntax_extensions" (SSE) that declares which optional
portions of the Muldis D grammar a programmer may employ with their
Muldis D code; the value for the new pragma is a set/list of SSE to
activate; the pragma is optional to specify and defaults to the empty
set (meaning core syntax only). Updated the main pod section "LANGUAGE
NAME" and added the new main pod section "STANDARD SYNTAX EXTENSIONS"
(located just following "CATALOG ABSTRACTION LEVELS").
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Refactored the syntax for
opaque value literals of the UTC/float date and time types of the
DateTime.pod language extension so that this syntax now constitutes a
new "date_time" standard syntax extension. And so the core standard
syntax now only includes support for types and routines that are part
of the Muldis D language core; supporting special syntax for non-core
types or routines is now optional. Added new pod sub section of
"STANDARD SYNTAX EXTENSIONS" named "date_time" and added new pod main
section "DATE-TIME EXTENSION OPAQUE VALUE LITERALS" (located just prior
to "NESTING PRECEDENCE RULES"). Moved the pod sub-section "UTC and
Float Temporal Literals" into the new main section and renamed it to
"Date and Time Literals". Updated the main pod section "VALUE LITERALS
AND SELECTORS" to move the 3 OVL node kinds "UTCInstant",
"FloatInstant", "UTCDuration" from there to the new "DATE-TIME ..."
main section. In the future, "DATE-TIME ..." may be expanded to have
more or better value literal syntax for DateTime.pod types, or have
special syntax for DateTime.pod routines.
* (PTMD_STD.pod) Corrected several instances of a fossil, left over
from the changes in version 0.79.0, where several uses of the
"Tuple_payload" grammar node should have been changed to "tuple_list".
* (PTMD_STD.pod) Added special shorthand syntax for name-expr pairs,
that may be used only if the "expr" is simply the name of a lexical
data element (expr node or param or var) and the name of that element
is identical to the "name" of the pair, and lets you specify the
identical name just once. For example, "foo => $foo" may alternately
be written as "$>foo", which has the exact same semantics. The 2 main
parts of the grammar this affects is the attr-expr pairs in tuple or
relation or scalar literals, and param-expr pairs in routine calls.
The HDMD_Perl[6|5]_STD dialects have no corresponding shorthand, since
there a set of name-value pairs are usually specified with a Perl Hash.
All corresponding grammar or description updates, and sample code
additions so far are in these 2 pod sub-sections: "Tuple Selectors",
"Generic Function Invocation Expressions". Also updated relevant code
seen in "FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS" subsections.
* (Bool.pod) The conceptual "proposition" operation is now also known
as "so", since that complements "not" like "negation" complements the
longer term (idea from Perl 6 spec update on 2009.12.17).
* Reorganized the TODO file with item groupings by broad subject.
2009-11-30 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.102.0 is released on CPAN as
Muldis-D-0.102.0.tar.gz.
* (Basics.pod, Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod)
In a reversal of one aspect of release 0.57.0, temporarily removed the
language concept of "topic namespaces". This change was made so that
some other language changes would be easier do. The concept of "topic
namespaces" will likely return in a future release, if other language
developments haven't made it redundant. In Basics.pod, updated the
"ENTITY NAMES" main pod section to remove the primary namespace "tpc"
("topic"), and removed the whole pod sub-section "Time-Varying Topic
Namespaces". In Types_Catalog.pod, removed the catalog type
"TopicNSControlCat" (for "tpc.cat") plus the then-empty main pod
section "TYPES FOR DEFINING TOPIC NAMESPACE CONTROLS"; also updated the
description of the "namespaces" attribute of the "System" catalog type.
In Routines_Catalog.pod, removed the procedure
"select_topic_namespaces" plus the then-empty pod sub-section
"Procedures For Defining Topic Namespaces"; also updated the previously
existing 16 "create|drop" procedures for in-depot namespaces and
routines and types so they now have the explicit 2 parent
namespace-specifying parameters "depot" and "parent|subdepot". In
PTMD_STD.pod, updated the "DBMS Entity Name Literals" pod sub-section
to remove all references to the "tpc" top-level namespace.
* (Types_Catalog.pod) Simplified the "FedTypeMapSet" catalog type by
renaming its "map" attribute to "types" and retyping the attribute from
a "FedTypeMap" binary relation (that named type was then removed) to an
equivalent "set_of.NameChain".
* (Basics.pod, Types.pod, Types_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Replaced the 2 top-level entity namespaces
"dep" (depot) and "sdp" (subdepot) with the 1 top-level namespace "nlx"
(nonlexical). Now, all non-lexical user-defined entities in a depot
are referenced in just 2 ways; the "fed" top-level provides an absolute
path and the "nlx" top-level provides a relative path. The new "nlx"
is more like the old "sdp" than the old "dep" in that its path starts
in the most immediate subdepot (or depot) parent of the referencing
entity, but unlike "sdp", "nlx" can also navigate to parent namespaces,
and so is fully capable of referencing anything in the referencer's
depot. The new "nlx" avoids the limitations of the old
quasi-absolute-path "dep|sdp" in that it still works regardless of
which of the referencing entity's parent namespaces is mounted in a
DBMS as a "depot"; it makes writing portable code much easier, such
that the code itself can be invariant between storage and live
representation. In Basics.pod, updated the "ENTITY NAMES" main pod
section, and its pod sub-section "User-Defined Entities", with the
aforementioned primary namespace replacements. In all 6 files,
replaced any references to "dep" or "sdp" in documentation and code
examples with "nlx" as appropriate.
* (Types_Catalog.pod) Eliminated the catalog type "MaterialRef" and
all of its 8 subtypes (and the whole "TYPES FOR SPECIAL ENTITY
REFERENCES" main pod section), and so now the only "Reference" type
left in Muldis D is "External". Replacing the "MaterialRef" types, for
purposes of passing references to materials as routine arguments or for
implementing higher-order functions or closures, is a new set of scalar
"NameChain" subtypes and a new set of possibly-not-dh tuple types. For
each of the "MaterialRef" types, all uses of it have been replaced with
uses of generally a single new type; the replacements are as follows
(all types have "sys.std.Core.Type.Cat.\w+" names):
"MaterialRef" -> "AbsPathMaterialNC",
"FuncRef" -> "APFunctionNC" + "CurriedFuncNC",
"[OrdDet|Val[Filt|Map|Red]]FuncRef" ->
"[OrdDet|Val[Filt|Map|Red]]CFuncNC",
"[Upd|Proc|Type]Ref" -> "AP[Updater|Procedure|Type]NC";
also added the 3 closely related new types "MaterialNC", "APNonTypeNC",
"RelPathMaterialNC" which are not direct replacements for
"MaterialRef" types. The 5 new types named "CurriedFuncNC" and
"\w+CFuncNC" are the tuple types, and all represent a function
reference plus 0..N prebound parameters; the other 8 new types are all
"NameChain" subtypes and represent just a plain entity reference. The
5 new tuple types comprise a new main pod section named "TYPES FOR
POSSIBLY CURRIED HIGHER-ORDER FUNCTIONS".
* (Types_Catalog.pod) Renamed the 2 catalog types
"MaterialRefSel[Expr|Stmt]NodeSet" to
"APMaterialNCSel[Expr|Stmt]NodeSet" and tightened the declared types of
each of their "referencing" parameters from "NameChain" to
"RelPathMaterialNC"; the purpose of these catalog types has been
modified to derive absolute path name chains from relative path
name-chains, rather than derive opaque reference values from name
chains. Also updated each of the 2 catalog types "[Expr|Stmt]NodeSet"
to rename its "material_ref_sel_[expr|stmt]s" attribute to
"ap_material_nc_sel_[expr|stmt]s".
* (Routines_Catalog.pod) Removed the "curried_func" catalog function,
which is no longer necessary since ordinary tuple operators can be used
instead for the same purpose. (But a replacement function could be
added later as a useful alternate syntax perhaps.)
* (Basics.pod, Types.pod, Types_Catalog.pod, PTMD_STD.pod) Excised any
references to the removed "MaterialRef" types. In Basics.pod,
simplified the description of the "reference" type category so that
only the "External" type is mentioned as an example, rather than also
the "MaterialRef" types. In Types.pod, updated the "Reference" type to
make its default value the same as "External" rather than the same as
"MaterialRef". In Types_Catalog.pod, updated the description of the
"special_types" attribute of the "System" catalog type to remove
"MaterialRef" from its list. In PTMD_STD.pod, substituted appropriate
type name references in the "MATERIAL SPECIFICATION" main pod section
and the "Library Entity Reference Selector" pod sub-section.
* (Universal.pod, Scalar.pod, Tuple.pod, Relation.pod, Set.pod,
Array.pod, Bag.pod, Interval.pod, Routines_Catalog.pod, Counted.pod)
Updated all system defined function signatures that take material
references or curried functions as arguments so that they take the new
scalar/tuple types rather than the old reference types.
* (Types_Catalog.pod) Added these 4 catalog types that are all
"NameChain" subtypes, for support of the next change item:
"RPFunctionNC", "RPTypeNC", "DataNC", "LexDataNC".
* (Types_Catalog.pod) For each tuple|relation catalog type, updated
each attribute whose declared type was "NameChain" so that it now has
one of these 6 more restricted declared types: "MaterialNC",
"APTypeNC", "RPFunctionNC", "RPTypeNC", "DataNC", "LexDataNC". These 5
attributes are now declared with "MaterialNC": "SysCatSet.catalog",
"FuncInvoExprNodeSet.function", "MultiUpdStmt.updater",
"UpdInvoStmtNodeSet.updater", "ProcInvoStmtNodeSet.procedure". These 1
attributes are now declared with "APTypeNC": "FedTypeMapSet.types".
These 15 attributes are now declared with "RPFunctionNC":
"ScalarType.[subtype_constraint|default|order]",
"PossrepSet.constraint", "PossrepMapSet.[p2_from_p1|p1_from_p2]",
"NonscalarType.[tuple|relation]_constraints",
"NonscalarType.default_[tuple|relation]",
"VirtualAttrMapSet.virtual_attr_map",
"[Union|Subset]Type.[constraints|default]". These 9 attributes are now
declared with "RPTypeNC": "Depot.data", "Function.result_type",
"ScaSelExprNodeSet.type_name",
"[Scalar|Nonscalar|Subset]Type.base_type",
"UnionType.[sources|filters]", "NameTypeMap.type". These 7 attributes
are now declared with "DataNC": "SysCatSet.name",
"OVLScaValStmtNodeSet.target", "IISArgVarMap.var",
"IfThenVarStmtMap.if", "GivenWhenDefStmtNodeSet.given",
"WhenThenVarStmtMap.when", "APMaterialNCSelStmtNodeSet.target". These
1 attributes are now declared with "LexDataNC":
"AccExprNodeSet.target".
2009-11-26 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.101.0 is released on CPAN as
Muldis-D-0.101.0.tar.gz.
* This release features a rough cut (that might have introduced a few
subtle mistakes) of a mass reorganization of Muldis D system-defined
routines, plus a few minor data types, both between what pod files they
are described in and between what "sys.*" name-spaces they live in. A
majority fraction of the materials that were considered to be part of
language "extensions" have been promoted to be part of the language
"core" instead. Also, the generic "Routines.pod" has been completely
split up into type or subject specific files. The main reason for
these changes is to make the language design better reflect what is
most likely to happen with actual implementations. The old "core"
tried to exclude too much and be too minimal, and there were a number
of conceptual problems such as a high degree of conceptual
inter-dependencies between what otherwise should be independent
extensions. The new "core" should better reflect a practical minimum
of functionality for a programming language, and the new "extensions"
are now more limited to the relative fringe of functionality that is
neither required to define any part of the core and is relatively
complicated and is relatively likely to not be easy to implement
everywhere; moreover, it should be much less likely now that any
extension would depend on another extension. The expanded "core" now
has all of the order-concerning operators, all of the defined
relational operators except the "Counted" ones, and it has all of the
operators for booleans, numerics, strings, intervals, and for TAI
temporals. The reduced "extensions" now has just the "Counted"
relational operators, all of the types and operators for temporal data
expressed as UTC dates and times, and all of the spatial types and
operators. In the future, when support for non-trivial pattern
matching or regular expressions are added, those will also be as
extensions, one extension per distinct pattern match engine/grammar,
because those would be both complicated and sometimes non-portable.
This release does not add or remove or alter the semantics of any types
or routines, but simply moves around or renames them. Just one
exception, where a minor type used to have 2 names and now has one.
* Split Ext/Temporal.pod into itself plus the new Ext/DateTime.pod; the
former has the 7 TAI-specific functions
"sys.std.Temporal.Instant.[[|abs_]diff|later|earlier]",
"sys.std.Temporal.Duration.[abs|sum|diff]" and the 1 TAI-specific
system-service "sys.std.Temporal.Instant.fetch_curr_instant" but no
data types (all 2 TAI types are in Core/Types.pod); the latter has all
of the 14 types, 11 functions, 6 system-services that are not
TAI-specific, and are all formatted in terms of YMDHIS in the UTC or
floating time-zone, and the latter has the 2 functions for TAI-UTC
conversion. So the simple TAI temporals (for time-stamps) and
complicated UTC temporals (for user datetimes) are now fully separated.
The TAI materials kept their "sys.std.Temporal.\w+" name-spaces while
the UTC materials were renamed to "sys.std.DateTime.\w+".
* Promoted 13 files and all of the materials (routines and types)
defined therein from Ext/ to Core/: Array.pod, Bag.pod, Blob.pod,
Bool.pod, Integer.pod, Interval.pod, Ordered.pod, Rational.pod,
Relation.pod, Set.pod, Text.pod, Temporal.pod, Tuple.pod. In every one
of these files, added "Core." to the name-spaces of every material, so
for example every "sys.std.Integer.\w+" became
"sys.std.Core.Integer.\w+". Only 3 files remain in Ext/: Counted.pod,
DateTime.pod, Spatial.pod; their materials' name-spaces are unchanged.
* (Routines.pod, Routines_Catalog.pod) Moved to Routines_Catalog.pod
from Routines.pod all 6 "sys.std.Core.Control.\w+" routines (2
functions, 1 updater, 3 procedures), which are now grouped into 2 new
main pod sections. The section "ROUTINES FOR INVOKING ROUTINES" got
the 4 "[func|upd|proc]_invo", "curried_func" and the section "ROUTINES
FOR WORKING WITH EXCEPTIONS" got the 2 "fail", "try_catch". Each of
the 6 had "Cat." added to its name-space and "Control." removed, ending
up with "sys.std.Core.Cat.func_invo" for example.
* Added new initially-empty file Core/Cast.pod whose purpose is to
consolidate all the type-casting routines that are conceptually monadic
functions between 2 core types.
* (Cast.pod, Routines.pod, Integer.pod, Rational.pod, Blob.pod,
Bag.pod) Moved to Cast.pod from Routines.pod the 2 functions
"Tuple_from_Relation", "Relation_from_Tuple"; from Integer.pod the 6
functions "Int_from_Text", "Text_from_Int", "Int_from_Blob_[S|U]_VBE",
"Blob_[S|U]_VBE_from_Int"; from Rational.pod the 4 functions
"Int_from_Rat", "Rat_from_Int", "Rat_from_Text", "Text_from_Rat"; from
Blob.pod the 2 functions "Set_from_Bag", "Bag_from_Set"; from Bag.pod
the 2 functions "Blob_from_Text", "Text_from_Blob". Moved to Cast.pod
the 2 types PInt2_36, PInt1_4; the first was in each of Integer.pod and
Rational.pod (2 copies with distinct long names), and the second was in
Blob.pod; the sole purpose of those types was to support the routines
moved from the same files. Following these moves, Integer.pod and
Blob.pod no longer declare any types, but Rational.pod has 2 others.
All materials in Cast.pod were renamed into "sys.std.Core.Cast.\w+".
* Added 3 new initially-empty files Core/Universal.pod,
Core/Scalar.pod, Core/STDIO.pod.
* (Routines.pod, Universal.pod, Scalar.pod, Bool.pod, Tuple.pod,
Relation.pod, STDIO.pod) Moved every one of the routines in
Routines.pod to one of 6 other files, such that each routine in the
name-space "sys.std.Core.<ns>.\w+" was moved to the same-named file
"<ns>.pod": Universal.pod got 7 functions, 1 updater; Scalar.pod got 13
functions; Bool.pod got 5 functions; Tuple.pod got 13 functions, 4
updaters; Relation.pod got 41 functions, 17 updaters; STDIO.pod got 7
system-services.
* (Ordered.pod, Interval.pod, Universal.pod) Moved the 2 functions
"sys.std.Core.Ordered.is[|_not]_member" from Ordered.pod to
Interval.pod, in the process renaming them to
"sys.std.Core.Interval.value_is[|_not]_member". Then moved the
remaining 10 Ordered.pod functions into Universal.pod, renaming each
one from the "Ordered." name-space to the "Universal." name-space.
* Removed the 2 now-empty files Core/Routines.pod, Core/Ordered.pod.
* (Text.pod) Made a note that each kind of regex / non-trivial pattern
match supported will be in its own extension, only 'like' in the core.
* Updated nearly every file that declared system-defined types or
routines to rename most of the headings for main pod sections that
featured said declarations. The new names are more modern, eliminating
any redundant "SYSTEM-DEFINED" text and now generally being of a format
like "FUNCTIONS FOR X" rather than "X FUNCTIONS". Similarly updated
headings of many pod sub-sections of such mains where they exist.
* (README, D.pm, Basics.pod, Core.pod, Types.pod, Types_Catalog.pod,
PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated any references in other
files to the moved/renamed/etc materials/etc.
2009-11-21 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.100.0 is released on CPAN as
Muldis-D-0.100.0.tar.gz.
* (Basics.pod, Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Temporarily removed the concept of private
routines and types from Muldis D; now all entities living directly in a
depot or subdepot are public, end of story; only lexical entities are
still private. This change was made to support some other language
simplifications to follow. The concept of private vs public will
return in a future release, but will likely be supported in a different
manner than before, and will probably return around the same time that
the concept of per-database-user entity access privilages come to be
defined. In Basics.pod, TODO-commented-out a few sentences in the 2
pod sub-sections "User-Defined Resources" and "Conceptions and
Requirements". In Types_Catalog.pod, updated each of the 7 catalog
types "[Function|Updater|Procedure]Set",
"[Scalar|Nonscalar|Union|Subset]TypeSet" to remove its "is_public"
attribute (which is now effectively always true), and did a few
TODO-comment-out in the file. In Routines_Catalog.pod, updated each of
the 7 routines "create_[function|updater|procedure]",
"create_[scalar|nonscalar|union|subset]_type" to remove its "is_public"
parameter. In each of the 3 STD.pod files, updated "Material
Specification Common Elements" so that a "material" node no longer has
an optional "priv_or_pub" element; where omitting it before meant
"private", all "material" which now don't have it anyway are "public";
also updated all code examples in the files appropriately.
* (Basics.pod) In the "ENTITY NAMES" main pod section, consolidated
each ".<type>" plus ".<routine>" line pair into a ".<material>" line.
* (HDMD_Perl6_STD.pod) In accordance with the latest Perl 6 spec (an
update on 2009.11.17), mentioned that the Perl 6 "FatRat" type exists,
alongside its "Rat". At this point, "FatRat" is actually the closest
approximation to the Muldis D "Rat", since the new Perl 6 "Rat" doesn't
have a denominator larger than a 64-bit integer can represent.
2009-11-06 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.99.0 is released on CPAN as
Muldis-D-0.99.0.tar.gz.
* (Basics.pod) Added new terms 'atomic', 'transaction' to the NOTES ON
TERMINOLOGY section, in order to help both distinguish those terms from
each other, and avoid misconception of the Muldis D spec in general.
* (Types_Catalog.pod) Fixed omission from "TYPE SUMMARY" section.
* (Makefile.PL, D.pm, Muldis_D_00_Compile.t) Updated the distro so
that normal users only need the most minimal dependencies reasonably
possible, meaning it now only requires Perl 5.6.0+ rather than 5.8.1+,
and it requires no modules at all that weren't bundled with 5.6.0+.
This seemed appropriate since the distro is documentation-only and
doesn't have any normal code to run, just POD to render (on the other
hand, that POD *is* UTF-8). Updated the test file, which exists just
to make generic CPAN build and testing facilities happy, to use "Test"
rather than "Test::More" since that's all Perl 5.6.0 bundled. Also
updated the Makefile.PL (and META.yml) to add "resources" urls.
* Updated all author references to change Darren Duncan's stated email
address from "perl@DarrenDuncan.net" to "darren@DarrenDuncan.net".
2009-10-20 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.98.0 is released on CPAN as
Muldis-D-0.98.0.tar.gz.
* (Types_Catalog.pod) Added new scalar catalog type
"sys.std.Core.Type.Cat.OVLScalar", which is an explicitly defined union
type over all of and just the system-defined DH-scalar types for whose
values all of the Muldis D standard dialects provide "opaque value
literal" syntax for, which is currently 18 scalar root types. Also
updated the "ScaValExprNodeSet" catalog type so that its "value"
attribute is now simply an "OVLScalar" rather than
"DHScalar"-plus-vague-constraint-description. This change should help
improve portability between Muldis D implementations and dialects, as
previously what "value" was allowed to contain was specified
implementation or dialect dependent.
* (Types.pod, Types_Catalog.pod, Integer.pod, Blob.pod, Rational.pod,
Temporal.pod) Updated the "TYPE SUMMARY" main pod section to insert
new "OVLScalar" between "DHScalar" and latter's hierarchy descendants.
* (Types_Catalog.pod, Routines_Catalog.pod, PTMD_STD.pod) Renamed the
2 catalog types "Sca[Val|PRSel]ExprNodeSet" to
"[OVLScaVal|ScaSel]ExprNodeSet", respectively. Also updated the
"ExprNodeSet" catalog type to rename is 2 attributes
"sca_[val|pr_sel]_exprs" to "[ovl_sca_val|sca_sel]_exprs".
* (PTMD_STD.pod) The Muldis D dialects are now a bit stricter in
semantics such that they now specify that when code is written using a
specific kind of "value" node kind, the parser must use the same
catalog data types for every case of the same node kind, rather than
taking liberties in the name of optimization. In particular, a
"Scalar" node must now *always* parse into a ScaSelExprNodeSet tuple,
even if its child exprs are all constants and it denotes a
system-defined type value; conversely, a "Rat" or "UTCInstant" etc node
must always parse into an OVLScaValExprNodeSet tuple. Likewise for
nonscalar selectors. The parser must retain as much as possible of the
specific syntax the user wrote. Any optimization must now be separate
from the parser, such as a separate distinct parser step that the user
must explicitly ask for, or a runtime/JIT feature for how the
system-catalog is compiled to machine code.
* (Types_Catalog.pod) Added 2 new catalog types
"[OVLScaVal|MaterialRefSel]StmtNodeSet", each node in which represents
assignment to a procedure variable of a newly selected OVL-scalar or
material ref value, respectively (which are short-hands that remove the
need to define/extend an updater to do this in most cases), and updated
the catalog type "StmtNodeSet" to add the 2
"[ovl_sca_val|material_ref_sel]_stmts" attrs.
* (HDMD_Perl[6|5]_STD.pod) Formatting typo fix.
2009-10-18 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.97.0 is released on CPAN as
Muldis-D-0.97.0.tar.gz.
* (Types_Catalog.pod, Routines.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod, Basics.pod) Split apart the unified facilities
for imperative routine invocation into disjoint facilities for invoking
updaters and procedures (system-services still being lumped with the
latter). In Types_Catalog.pod, split the catalog type
"ImpInvoStmtNodeSet" into the 2 "[Upd|Proc]InvoStmtNodeSet", and
updated the "StmtNodeSet" type to split the attribute "imp_invo_stmts"
into the 2 "[upd|proc]_invo_stmts". Also renamed the catalog type
"ImpRef" to "ProcRef" and rearranged the type hierarchy so that both
"UpdRef" and "ProcRef" are directly under "MaterialRef" rather than
"UpdRef" being under "ImpRef". In Routines.pod, renamed the procedure
"imp_invo" to "proc_invo" and renamed its "imperative" parameter to
"procedure". Following these changes, both the "proc_invo" and
"try_catch" procedures can now only take refs to procedures (or
system-services) as arguments, and no longer also refs to updaters. In
the 3 STD files, updated the "Library Entity Reference Selector" pod
sub-section to split the "imp-ref" node kind into the 2
"[upd|proc]-ref". In Basics.pod, a minor related desc update.
* (HDMD_Perl[6|5]_STD.pod) Updated the code examples in the "CATALOG
ABSTRACTION LEVELS" main pod section to reflect that the 1-2 payload
elements of a 'depot' node are each now wrapped in a Perl Pair or
single-elem hash-ref whose key is "depot-catalog" or "depot-data", so
to make depot declaration Perl-STD code better self-documenting. Then
further updated said examples to reflect that the 4th,5th,6th used
elements of a 'function' node (result-type, params, expr) are now
wrapped up in a function-payload Perl array ref, with that now being
the collective 4th element of 'function'.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Renamed the placeholder
"DEPOT DECLARATION" main pod section to "DEPOT SPECIFICATION" and
completely fleshed it out with updated grammar, description, and code
examples. So these main node kinds are now formally defined: "depot",
"subdepot", "self_local_dbvar_type"; the last of these is newly added
in PTMD_STD. In PTMD_STD, these grammar elements were renamed:
"depot_or_subdepot" -> "depot_catalog_payload",
"named_[subdepot|material]" -> "subdepot|material".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new main pod section
"MATERIAL SPECIFICATION", just following "DEPOT SPECIFICATION", which
has 1 sub-section "Material Specification Common Elements". Herein,
the "material" node is fully defined with grammar and description, and
has 7 main variants, one each for the 3 main routine kinds and 4 main
type-declaration methods. A material has 2-4 elements that are common
to all material kinds, which are material-kind, priv-or-pub,
material-declared-name, and material-payload.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In the "MATERIAL
SPECIFICATION" main pod section, added these 7 empty placeholder pod
sub-sections, which will be populated in near-future spec releases:
"[Function|Updater|Procedure|[Scalar|Nonscalar|Union|Subset] Type]
Specification".
2009-10-14 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.96.1 is released on CPAN as
Muldis-D-0.96.1.tar.gz.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the "LANGUAGE NAME"
main pod section to make example code invoke highest abstraction level.
* (Routines.pod, Routines_Catalog.pod, Ordered.pod, Bool.pod,
Integer.pod, Blob.pod, Text.pod, Rational.pod, Tuple.pod, Relation.pod,
Set.pod, Array.pod, Bag.pod, Interval.pod, Counted.pod, Temporal.pod)
In a reversal of one aspect of release 0.62.2, reformatted all
system-defined routine signatures to match the planned new PTMD_STD
format for declaring routines, such that the type annotation for each
parameter is now on the right side of the parameter name rather then on
the left side. Where parameter declarations used to be formatted "T1
$p1" or "T1 &$p1" or "T1 $p1?", they are now formatted "$p1 : T1" or
"&$p1 : T1" or "$p1? : T1". (Not yet shown, this formatting change
will also apply to type attribute declarations and variable
declarations, etc.) This change only slightly increases the verbosity
(opt by 2 chars per param) but carries a number of benefits: 1. The
PTMD_STD dialect now has greater similarity to the HDMD_Perl[6|5]_STD
dialects, which already have each param's type annotation on the right
side of the param's name. 2. Having the type annotation on the
right-hand side also better lends itself to code that defines a type
inline with the code where it's used (likely to be very common), which
should make code an order of magnitude easier to read in the general
case. 3. Even without the possibility of embedding, the code should be
easier to read now than before. 4. With this formatting change, Muldis
D in general is now more similar to both SQL and Tutorial D etc than
before, important to help with learnability or migration. Now while
this change does make Muldis D a bit less like Perl 6 or C languages,
it does then become more like (besides SQL etc) Haskell or Pascal or
Scala or JScript (also the last 3 share the colon separator).
* (PTMD_STD.pod) Updated 2 code examples according to prior chg item.
2009-10-13 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.96.0 is released on CPAN as
Muldis-D-0.96.0.tar.gz.
* (Types_Catalog.pod) Relaxed the restriction on when system-defined
routine definitions in the system-catalog may have specified routine
bodies; now any function|updater|procedure either may have or may omit
a body. Updated the 2 catalog types "Sys[Upd|Proc]Set" to add a
"body" attribute like that of "SysFuncSet", all 3 less restrictive.
* (Types_Catalog.pod) Refactored the catalog types for specifying
routines so they are more like the ones for specifying types; merged
the type-pairs that specified routine headings and bodies into single
types that specify both. Merged the 6 catalog types
"[Func|Upd|Proc][Head|Body]" into the 3 "Function|Procedure|Updater";
the post merge types have all of the same attributes as the originals
but for now only having 1 "comment" each rather than 2. The post-merge
versions were also enhanced so that all of the attributes for
specifying the routine bodies are now optional (to support
system-defined routines in general); these attributes all happen to be
relations or tuples of relations, and so a routine body is assumed to
be missing when those relations are all empty and existing when at
least one has a tuple. Also a minor corresponding update to the
"MultiUpdStmt" catalog type. Also renamed the 6 catalog types
"[|Sys][Func|Upd|Proc]Set" to "[|Sys][Function|Updater|Procedure]Set"
and for each one updated it to merge its 2 "head|body" attributes into
the 1 "material" attribute. Also updated each of the 8 catalog types
"[|Sys][Scalar|Nonscalar|Union|Subset]TypeSet" to rename its "type"
attribute to "material".
* (Routines_Catalog.pod) Corresponding to the prior change item,
updated each of the 3 catalog procedures
"create_[function|updater|procedure]" to merge its 2 "head|body"
parameters into the 1 "material" parameter. Also updated each of the 4
"create_[scalar|nonscalar|union|subset]_type" to rename its "type"
parameter to "material".
* (PTMD_STD.pod) Updated the "DEPOT DECLARATION" main pod section to
refactor the "depot" node; the "<Database> | <depot_or_subdepot>" value
choice for "depot-catalog" has been factored out to a "catalog" node.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the "Scalar
Selectors" pod sub-section to add 2 code examples on how to select
"Int" or "Text" values just in terms of the singleton "String.*" types.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the "LANGUAGE NAME"
main pod section to make the "ln_extensions" 5th name part mandatory
rather than opt, because at least one mand pragma will be added next.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Generalized the
"with_rtn_inv_alt_syn" pragma into the "catalog_abstraction_level"
pragma, where the latter is more extensible, and defines concentric
subsets of Muldis D grammar size, where the larger/higher ones are
increasingly abstracted from the system catalog representation of
Muldis D code. The "plain_rtn_inv" and "rtn_inv_alt_syn" values for
the new pragma are direct matches for the "false" and "true" values,
respectively, of the old pragma; the "plain_rtn_inv" level represents
almost all system-defined operators as polish notation routine calls
like user-defined ones would be, while the highest "rtn_inv_alt_syn"
level adds terser special syntax for over a hundred built-in operators,
to resemble other general purpose languages the most. The new pragma
also has 2 additional values: A new lower level "code_as_data" is as
direct a match as possible for the system catalog, presenting the
system catalog as a "Database:Depot" value literal, which also harkens
back to earlier days of the Muldis D spec when the concrete grammar was
only capable of specifying value literals. A new yet-lower level
"the_floor" exists just for academic purposes, showing how far one can
go to strip down the grammar but still support all Muldis D semantic
features. Replaced the old main pod section "MULDIS D STANDARD DIALECT
PRAGMAS" with the new main pod section "CATALOG ABSTRACTION LEVELS"
(the latter located just following "LANGUAGE NAME"), which has a pod
sub-section for each of the 4 levels. The new main pod section
features a visual comparison of the 4 abstractions, by demonstrating
how to write the same simple Muldis D code in each of them. The 3
highest levels demonstrate how to write a complete depot (with language
name) which simply declares a function that results in the cube of its
integer argument. The 2 lowest levels demonstrate how to write a
simple 2x2 relation value literal. The "code_as_data" level had both
examples, the other 3 levels had just 1 example each. In PTMD_STD.pod,
each of the 4 abstraction levels has its own definition for the 3
grammar nodes "value", "catalog", "expr"; this is the semi-formal way
in which the effects of each level on the grammar are specified. The
old pragma just redefined "expr" for each level, not the other two.
In "NESTING PRECEDENCE RULES", noted "code_as_data" has just 1 prec lv.
2009-10-08 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.95.0 is released on CPAN as
Muldis-D-0.95.0.tar.gz.
* Oops, the previous releases 0.9[3|4].0 shipped with code all decl as
version 0.092000 rather than 0.09[3|4]000; metadata was correct though.
* (PTMD_STD.pod, Basics.pod) In the PTMD_STD dialect, split up the
"Comment" node into itself and the new "non_value_comment" node, where
each is now specialized for particular disjoint purposes. "Comment"
now has a payload delimited by backticks ("`") rather than hash-marks
("#"), with simple rules the same as "Text", and it is just used in
code like normal data is, and is the only version that a "value" or
"expr" node may "be". The new "non_value_comment" retains the more
complicated hash-mark-delimited syntax of the old version, and is now
just used in the "put it anywhere as metadata" use, and it never has a
prefix such as "Comment:". The new "Comment" is also now an 8th type
whose literals may always be a SCVL format in a GCVL context, because
it is distinguished as the only thing to use backticks. This split was
done partly to avoid the problems arising from when the same syntax was
useable both in a normal expression as well as sprinklable anywhere.
Both versions are members of the tightest nesting precedence level.
Also added new "escaped_char" "\g" to repr a backtick/grave-accent.
In Basics.pod, updated "NOTES ON TEXT CHARACTER LITERALS" re backticks.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Renamed the "payload" node to
"value_payload", so the name wouldn't conflict with future additions.
* As a new general design change, all multi-word keywords in Muldis D
that would otherwise be written out either with single underscores
between the words or whitespace between the words will instead have
single hyphens between the words officially. This affects all the
names of routine kinds, and the leading keywords for many kinds of
entity definitions in the concrete grammars, and any infix/etc operator
name tokens in the grammars. A benefit of this change is that
tokenizing Muldis D code should be easier, and there is more
consistency between the plain-text and Perl-hosted-data dialects as to
how the various keywords are spelled, especially since possibly
variable whitespace in the middle of a keyword (or alternately the
enforcement of user-error-prone single spaces) is now off the table.
Also, hyphens were used instead of underscores because arguably they
read better, more like the whitespace they mean to loosely represent,
and hyphens are easier to type, and also hyphens stand out more
visually since multi-word entity names (materials, variables, etc) are
typically underscore-sep by convention (hyphens legal there though).
* (Basics.pod, Types.pod, Types_Catalog.pod, Routines.pod,
Routines_Catalog.pod, Ordered.pod, Integer.pod, Rational.pod,
Tuple.pod, Relation.pod, Set.pod, Array.pod, Interval.pod,
Temporal.pod) In the "ROUTINES" main pod section of Basics.pod,
renamed all 11 routine kinds whose names had multiple words, replacing
any underscores with hyphens; the new names of those 11 routine kinds
are: "system-service", "[type|state|transition]-constraint",
"named-value", "possrep-map", "virtual-attr-map",
"order-determination", "value-[filter|map|reduction]". In all 14
files, updated any references on those routine kinds to the new names.
In the case of "system-catalog", some of these references were in the
signatures of the system-defined routines in the routine references.
* (HDMD_Perl[6|5]_STD.pod) Renamed 7 node kind keywords to replace any
underscores with hyphens; their new names are: "func-invo",
"if-else-expr", "given-when-def-expr",
"[func|proc|type|ord-det-func]-ref".
* (PTMD_STD.pod) Renamed 4 infix operator multi-word keywords from
forms that had exactly 1 space character between the words to have
single hyphens instead; their new names are: "cross-join", "not-isa",
"not-matching", "not-like". These were the only instances of
fixed-length whitespace inside multi-word keywords.
* (PTMD_STD.pod) In the "DEPOT DECLARATION" main pod section, changed
the syntaxes "depot \s+ [catalog|data]" to "'depot-[catalog|data]'",
respectively. These were the only instances of variable-length
whitespace inside multi-word keywords.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In the "Rational Operators
That Do Rounding" pod sub-section, renamed the "loge" postfix operator
keyword to "log-e", which is easier to read.
* (Routines.pod, Rational.pod, Text.pod) Updated the also-known-as
notes for 5 functions in correspondence to above-mentioned changes.
* (Types.pod, Array.pod) Typo fixes.
2009-10-05 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.94.0 is released on CPAN as
Muldis-D-0.94.0.tar.gz.
* This release features the addition of generic parameterizable
interval types to Muldis D as a core feature, where they are just as
much first-class citizens as the likes of "set", "maybe", "array", and
"bag". An "interval" is conceptually like a "set" but that rather than
its member values being defined via enumeration as with a normal
relation value, they are defined in terms of being every value of a
particular orderable type that is orderable between a particular pair
of endpoint values. An "interval" is represented in Muldis D as a
tuple with 4 attributes which define a pair of endpoint values plus an
indicator of whether each endpoint is included in the interval. The
language was also refactored in small suitable ways to use single
interval values where it used to use multiple values to represent
ranges or limits for an operation.
* (PTMD_STD.pod) Several instances of making the grammar stricter with
regards to whitespace. Updated every kind of "value" regarding the
value literal element separator (":") or value literal payload element
separator (";") that each value literal may have, so that instead of
there being optional whitespace just to the left of it, there must now
be no whitespace just to the left of it; for example, where "Int : 1 ;
11001001" used to be valid, it must now be such as "Int: 1; 11001001"
or "Int:1;11001001" instead. Also updated the "language_name" to
remove the optional whitespace just to the right of each ":" that is
between the language name elements. Also updated the "named_expr" so
that whitespace on both sides of the "::=" is now mandatory rather than
optional. Also updated the "func_invo" to remove the optional
whitespace between the function name and the argument list; for
example, where "myfunc ( 3 )" used to be valid, it must now be such as
"myfunc( 3 )"; this change is particularly important, as it should make
the parser simpler in how it determines whether the "myfunc" it
encountered is a keyword or special-syntax (which tend to have
mandatory separating whitespace) versus a generic function invocation,
especially with the previous release's changes concerning the explicit
expression delimiters being made optional.
* (PTMD_STD.pod) Updated the main pod section "NESTING PRECEDENCE
RULES" to add a new tighter precedence level for the triadic comparison
operators, so that the likes of "not $min < $foo ≤ $max" would now
parse as a single entity without say "$min < $foo" always being eaten
as a complete operation instead.
* (Types.pod, Basics.pod) In Types.pod, added 2 new generic tuple
types "sys.std.Core.Type.[|DH]Interval" to the language core, each of
which has 2 "Universal"-typed attributes named "min|max" and 2
"Bool"-typed attributes named "excludes_[min|max]"; the "min|max"
attributes are parameterizable as per the "value" attribute of the
Set|Array|Bag types. In Basics.pod, updated the "Referencing Data
Types" pod sub-section of "ENTITY NAMES" to add support for the terse
inline parameterized interval type decl prefixes "[|dh_]interval_of.".
* (Types_Catalog.pod) Added new catalog type "IvlSelExprNodeSet" which
supports a more compact representation of an Interval value selection
expression node than a "TupSelExprNodeSet" does; this is at the
Array|Bag-specific-selector-like limitation that the
"excludes_[min|max]" attributes of the Interval selector are
compile-time constants (which is typically okay); defining those
attributes at runtime requires the likes of a "TupSelExprNodeSet".
Also updated the catalog type "ExprNodeSet" to add a 13th attribute
"ivl_sel_exprs" of the new catalog type.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new pod sub-section
named "Interval Selectors" to the end of the main pod section
"COLLECTION VALUE SELECTORS", which declares new literal/selector
syntax specific to Interval values. An Interval selector is designed
to mimic the literal syntax and features of Perl 6's "Range" type, and
generally you define an Interval in terms of a pair of value literals
or expressions separated by one of these 4 character strings: '..',
'..^', '^..', '^..^'. For parsing simplicity an Interval GCVL in
PTMD_STD, the separated pair is delimited, for example as
"Interval:{10^..20}", but in some specific contexts the delimiter
wouldn't be necessary. In HDMD_Perl6_STD, a straight-up Perl Range may
be used to represent an Interval literal, such as "10^..20". In
HDMD_Perl5_STD, an Interval node payload is a 3 element Perl arrayref
with the string '^..'/etc being the middle element.
* (Ordered.pod) Renamed the 2 functions "is_[in|out]side_range" to
"is_[|not_]member" (with additional aka of "I∈", "I∉"), respectively,
and refactored their parameter lists so each of them now takes a single
"interval" argument rather than the 4 "min|max","m[in|ax]_is_outside",
and the "topic" param is renamed to "value"; the "func" param is
unchanged. The updated functions also now have more liberal semantics
that they no longer fail if "max" is before "min"; now they just treat
that scenario as "interval" being an empty interval, meaning all
candidate "value" would not be considered included in it. The existing
also-known-as notes for these functions were retained unchanged, save
for the additional ones.
* Added new file "lib/Muldis/D/Ext/Interval.pod" which houses the new
"Muldis D Interval Extension". This extension defines an initial
complement of 2 interval-specific new functions
"sys.std.Interval.has_[|not_]member" (aka "I∋", "I∌"). This function
pair and the prior-mentioned 2 in Ordered.pod are aliases for each
other. Still TODO is fleshing out Interval.pod with more functions.
* (D.pm, Core.pod, README) Added basic references to the new
Interval.pod file.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the "Order Comparison
Operators" pod sub-section corresponding to prior-mentioned changes.
Accounted for the changes to what functions the ternary operators like
"≤≤" map to, and so now each of those doesn't just map to a 5+ argument
function, but instead to a 4 argument Interval selector plus a 2+
argument function ("Ordered.is_[|not_]member"). Also added 4 new
dyadic compare ops 'I∈','I∉','I∋','I∌'; 1 per distinct new/chg interval
func. Also added an example code piece for "I∈" to all 3 files.
* (Relation.pod) Updated each of the 2 functions
"limit[|_by_attr_names]" to merge its 2 "m[in|ax]_rank" parameters into
a single "rank_interval" parameter. Each updated function is also more
flexible now such that tuples whose ranks match one or both of the
min|max may optionally be excluded from the result as per "^", and it
is now more liberal concerning max-before-min.
* (Array.pod) Updated each of the 3 functions "slice",
"limit_of_Array_from_wrap[|_by_attr_names]" to merge its 2
"[first|last]_index" parameters into a single "index_interval"
parameter. Each updated function is also more flexible now such that
elems whose indexes match one or both of the first|last may optionally
be excluded from the result as per "^", and it is now more liberal
concerning last-bef-first. Also this op is now aka "[]", not "[..]".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the "Simple
Postcircumfix Operators" pod sub-section corresponding to the
"Array.slice" changes. The "op" for "slice" is now "[]", not "[..]".
For both HDMD_Perl[6|5]_STD, the second main op arg of the "[]" op now
is simply an Interval node payload rather than a 2-element arrayref,
which for Perl 6 can just be a Perl Range. For PTMD_STD, accounted for
changes to the "slice" function that "[]" maps to.
* (Integer.pod, Rational.pod) Updated each of the 2 functions
"[Integer|Rational].fetch_random" to merge its 4 "[|exclude_]m[in|ax]"
parameters into a single "interval" parameter. Also expanded the
restriction against max-before-min to instead be against any empty
"interval".
* (Basics.pod, PTMD_STD.pod, Tuple.pod) Other minor updates and fixes.
2009-09-28 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.93.0 is released on CPAN as
Muldis-D-0.93.0.tar.gz.
* Updated the README file to indicate that this distribution now has 2
public Git repositories, one on GitHub.com and one on utsl.gen.nz.
* (PTMD_STD.pod) Changed the nature of expression-delimiting
parenthesis so that they are now completely generic and can delimit any
kind of "expr" at all, including themselves, and so they are optional
to use; this is all to be in keeping with common practice in
programming languages where generally the only reason to use expr
delimiting parenthesis is to force a particular nesting precedence for
sub-expressions. And so it is also no longer mandatory for if-else or
given-when-default or generic alternate function invocation syntax
expressions to have parenthesis delimiters, though in practice they may
often be used with such code anyway. Also updated all the code
examples that were entirely paren-delimited to remove said delimiters.
* (PTMD_STD.pod) Added new main pod section "NESTING PRECEDENCE RULES"
just above "SEE ALSO", which groups all the kinds of "expr" into about
7 precedence levels, so it is explicitly known when
expression-delimiting parenthesis may be safely omitted as far as a
parser is concerned, though in practice some parenthesis may still be
used when not needed simply to aid human readability. The basic order
from tightest to loosest precedence is: terms / value literals /
expression name useage / etc, accessors and postfix ops, prefix ops,
dyadic infix ops, infix reduction ops, if-else and given-when exprs,
expr-naming exprs. Also, most levels of ops are left-associative,
espec all reg infix. Also upd more code examples to rem more parens.
2009-09-26 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.92.0 is released on CPAN as
Muldis-D-0.92.0.tar.gz.
* As of this release, this Muldis D language specification distribution
no longer contains supplementary files that aren't part of the language
spec itself, and so any subsequent releases of this distribution should
always constitute spec updates, and not supplementary material changes.
* All of the files removed by this release are being released to CPAN
concurrently to this release as the initial content of the initial
release of the new distribution Muldis-D-Manual.
* The transferred files were all of the 10 files constituting the
entire archives/ and util/ folders:
archives/Muldis_D_PDAFP_200807_lt.xul
archives/Muldis_D_PDAFP_200807_sa.xul
archives/Muldis_D_PDAFP_200807_updated.xul
archives/OSCON2008SessionProposal.txt
archives/README
archives/takahashi.css
archives/takahashi.js
util/BBEdit_LM_Muldis_D.plist
util/Input_Method_Muldis_D.cin
util/README
* (SeeAlso.pod) Added new main pod section "FURTHER DOCUMENTATION"
which refers to the new Muldis::D::Manual distro, just above the
"INFORMATION SOURCES" main pod section.
* Updated the README file concerning the post-split status.
* This release has no other changes save for administering the above.
2009-09-21 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.91.0 is released on CPAN as
Muldis-D-0.91.0.tar.gz.
* (Types_Catalog.pod, Basics.pod) In a reversal of one aspect of
release 0.89.0, updated the catalog type "Depot" to re-add the
attribute "data", with which one can explicitly indicate whether the
depot/subdepot has a self-local dbvar, and if so what its declared type
is. Also updated the description of "Depot" to no longer say that a
child entity declared name of the empty string is reserved for any
purpose. In Basics.pod, added new pod sub-section named "Empty-String
Names" under "ENTITY NAMES", and made some large updates to the "User
Namespace Correspondence" sub-section. The changes/additions no longer
say that an empty string name is reserved for a dbvar type etc, nor
that a dbvar type can't be "just a database" (it now can if there are
no child subdepots or materials, and the language feature is added
about any namespace containing an empty string named material can now
be referenced directly as a proxy for said material, and this also
cascades if said parent namespace itself has an empty name.
* (Types_Catalog.pod) Corrected a mistake in the "Depot" catalog type
desc (intr by v0.90.0); it has a binary distrib primary key not unary.
* (Types_Catalog.pod, Routines_Catalog.pod, Basics.pod) Renamed the
concept of a restriction-defined type to a subset-defined type, mainly
because that name is shorter and can be used everywhere unabbreviated,
which gives consistency with the other 3 main ways of declaring types.
Renamed the 3 catalog types "RestrType", "[|Sys]RestrTypeSet" to
"SubsetType", "[|Sys]SubsetTypeSet", and updated each of the 2 catalog
types "Depot", "System" to rename its "restr_types" attribute to
"subset_types". Renamed the 2 data-definition procedures
"[create|drop]_restr_type" to "[create|drop]_subset_type".
* (Types_Catalog.pod) Updated each of the 7 catalog types
"[Func|Upd|Proc]Set", "[Scalar|Nonscalar|Union|Subset]TypeSet" to
rename its "subdepot" attr to "parent", to increase spec consistency.
* (BBEdit_LM_Muldis_D.plist) Updates corresp to recent spec changes.
2009-09-19 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.90.0 is released on CPAN as
Muldis-D-0.90.0.tar.gz.
* This release features a refactoring of the mid-level DBMS entity
namespaces, specifically [depot, subdepot, package, material/"inner"].
To start with, the distinct "package" concept has been eliminated, and
its only distinctive feature (the ability to designate each material as
either public or private) is now available to materials directly in
depots or subdepots; and so, a Muldis D subdepot now represents *both*
the SQL concept of a "schema" *and* the Oracle concept of a "package".
From the other end, the distinct concepts of "inner" and "outer"
materials no longer exists, such that an "outer material" was just a
proxy for one of several "inner material" that it encapsulated, the
others being support. Now instead, the "outer" has been replaced with
another layer of subdepot as required, and now every "inner" now lives
directly in the subdepot tree, and might be directly referenceable.
* (Basics.pod) Multiple updates throughout the "ENTITY NAMES" main pod
section, and in the "User-Defined Resources" pod sub-section of
"RESOURCE MODULARITY AND PERSISTENCE", to eliminate the distinct
concept of "package", such that any references to it were either
removed or changed to "subdepot"; similarly, the entity namespaces
"pkg.*" and "tpc.pkg.*" were eliminated, and any references either
removed or changed to "sdp.*" or "tpc.sdp.*", respectively.
* (Types_Catalog.pod) Renamed the "DepotOrPackage" catalog type to
"Depot" (and renamed the main pod section "TYPES FOR DEFINING DEPOTS
AND SUBDEPOTS AND PACKAGES" to remove the " AND PACKAGES"), and removed
its "packages" attribute, and updated its description to now say it
represents a depot/subdepot only and not also a package. Also removed
the "PackageSet" catalog type. Also updated the "MaterialSet" catalog
type to remove its "package" attribute and to update the type of its
"is_public" attribute from "maybe_of.Bool" to plain "Bool", and updated
its description as appropriate. Also updated the "TopicNSControlCat"
catalog type to remove its "topic_package" attribute. Also updated the
descs of the 3 catalog types "System", "SubdepotSet", "Material" and
the text of the "TYPES FOR SPECIAL ENTITY REFERENCES" main pod section.
* (Routines_Catalog.pod) Removed the whole pod sub-section "Procedures
For Defining Package Routines and Data Types"; removed the 2 procedures
"[create|drop]_package_material". Also added a "is_public" parameter
to the "create_depot_material" procedure. Also removed the 2
procedures "[create|drop]_package". Also removed the "package"
param of the "select_topic_namespaces" proc. Also other rel desc chgs.
* (Basics.pod) Multiple updates throughout the "ROUTINES" and "ENTITY
NAMES" main pod sections, to eliminate the distinction between "inner"
and "outer" materials (types and routines). Removed the 3 routine
kinds "inner_[function|updater|procedure]" and any not removed
references to them were replaced by references to their non-"inner_"
counterparts. And so now there are just 4 primary routine kinds left,
[function, updater, system_service, procedure], and *all* of them may
be invoked from another host language. The entity namespace "inn.*"
was eliminated, and any references either removed or changed to
"sdp.*". Most of the new description text additions under "ENTITY
NAMES" were in the "Conceptions and Requirements" and "User Namespace
Correspondence" pod sub-sections; in the latter, added the new feature
that a subdepot/relvar duality may now exist, so that we now
conceptually are able to bundle a relvar's type definition into the
relvar, as SQL does.
* (Types_Catalog.pod) Updated all 7 catalog types ("Possrep[|Map]Set",
"Inner[Scalar|Nonscalar|Union|Restr]Type", "VirtualAttrMapSet") having
at least 1 attribute that held a reference to a routine (a function in
every case), and changed the declared type of every one of the 15 such
attributes to "NameChain" from "Name". Prior to the change, all such
referenceable routines had to be "inner" routines, but now the routines
may be anywhere. Each changed attribute had 1 of these 12 names:
"[|subtype_]constraint", "[|tuple|relation]_constraints",
"default[|_[tuple|relation]]", "p1_from_p2", "p2_from_p1",
"virtual_attr_map", "order".
* (Types_Catalog.pod) Renamed the 10 catalog types
"Inner[Func|Upd|Proc][Body|Set]",
"Inner[Scalar|Nonscalar|Union|Restr]Type" to remove the "Inner", the 4
"Inner[Sca|Nonsca|Uni|Restr]TypeSet" to
"[Scalar|Nonscalar|Union|Restr]TypeSet", and updated the "Material"
catalog type to rename its 7 attributes "inner_[func|upd|proc]s",
"inner_[sca|nonsca|uni|restr]_types" to
"functions|updaters|procedures",
"[scalar|nonscalar|union|restr]_types". Also renamed the 3 main pod
sections "TYPES FOR DEFINING INNER [ROUTINE [HEADINGS|BODIES]|DATA
TYPES]" to remove the "INNER ". Also updated any other documentation
references to "inner|outer types/etc" to remove the "inner|outer".
* (Types_Catalog.pod) Some pod section rearranging, which has no
material effect on the spec. Merged the 2 main pod sections "TYPES FOR
DEFINING ROUTINE [HEADINGS|BODIES]" into the 1 "TYPES FOR DEFINING
ROUTINES"; each of the 3 catalog type decl "[Func|Upd|Proc]Head" was
moved downwards so it is now directly above its corresponding
"[Func|Upd|Proc]Body" type decl. Merged the 1 main pod section "TYPES
FOR DEFINING ROUTINES AND DATA TYPES" into the 1 "TYPES FOR DEFINING
DEPOTS AND SUBDEPOTS"; the "Material" catalog type decl was moved
upwards so it is now directly below the "Depot" type decl.
* (Types_Catalog.pod) Annotated the "TYPES FOR SPECIAL ENTITY
REFERENCES" main pod section to say it still requires heavy editing.
* (Types_Catalog.pod) Merged the catalog type "Material" into "Depot";
the combined type has the 7 attributes "functions|updaters|procedures",
"[scalar|nonscalar|union|restr]_types" from "Material" plus the 2
attributes "comment", "subdepots" from "Depot" but not "materials" from
"Depot". Merged the catalog type "MaterialSet" separately into all 7
of "[Func|Upd|Proc]Set", "[Scalar|Nonscalar|Union|Restr]TypeSet"; each
of the 7 types kept all of its existing 3-4 attributes ("name",
"comment" and "head", "body" or "type") and also gained the 2
"subdepot", "is_public" from "MaterialSet" and also now has a binary
primary key. Refactored the catalog types for declaring/defining
system-defined materials. The "SysTypeSet" catalog type was split into
the 4 "Sys[Scalar|Nonscalar|Union|Restr]TypeSet", which are identical
save for what kind of "*Type" catalog type they embed; the catalog type
"System" was also updated so its "types" attribute was split into the 4
"[scalar|nonscalar|union|restr]_types". Updated the "SysFuncSet"
catalog type to add a "body" attribute which is "Maybe" typed; the idea
is that functions which are just part of the definition of a
system-defined type will have their bodies defined, while normal s-d
functions won't.
* (Routines_Catalog.pod) As a partial reversion to version 0.77.0 of
the language spec, split the 2 data-definition procedures
"[create|drop]_depot_material" into the 14
"[create|drop]_[function|updater|procedure]",
"[create|drop]_[scalar|nonscalar|union|restr]_type".
* (PTMD_STD.pod) Refactored the grammar nodes in the "DEPOT
DECLARATION" main pod section to merge package stuff into subdepot
stuff. Also updated the "Generic Function Invocation Expressions" pod
sub-section to excise mention of the "inn" namespace getting the
special cases that "sys.std" gets regarding positional arguments, where
parameters of any names may take positional ars if there are just 1-2
mandatory ones. Also small desc updates in "DBMS Entity Name Literals"
to remove mention of 'pkg' and 'inn'.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated all the code examples
to use the "sdp.lib.*" namespace. where they used "inn.*". Related
small description changes.
* (Basics.pod, Types.pod, Types_Catalog.pod) Other minor description
updates corresponding to recent spec changes.
* (Muldis_D_PDAFP_200807_updated.xul) Upd corres to recent spec chgs.
2009-09-13 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.89.0 is released on CPAN as
Muldis-D-0.89.0.tar.gz.
* (Types_Catalog.pod, Basics.pod) Updated the "DepotOrPackage" catalog
type to remove its "data" attribute, which had been the main indicator
of whether a depot/subdepot/package had a self-local dbvar and if so
then what its type was. Now instead, the data type of every
depot/etc's self-local dbvar is defined by that depot/etc's immediate
child data type definition whose declared name is the empty string; so
empty-string names in the public namespaces are now reserved for this
purpose and one may no longer declare a
subdepot/package/material/relvar with the empty string for a name,
except for the single item with that implicit purpose. Also updated
the "User Namespace Correspondence" pod sub-section of "ENTITY NAMES"
with corresponding description changes. Also in the same sub-section,
updated the mention of the possibility of using "just a database" as
the declared type of a self-local dbvar, so to say that this is
actually impossible, and that at least some database values would have
to be disallowed due to namespace conflicts with their attribute names.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Moved the main pod section
"DEPOT DECLARATION" upwards to be just before the main pod section
"GENERIC VALUE EXPRESSIONS". So from now on, grammar elements which
are not part of the "value" sub-language are now declared in roughly
the same order as their corresponding system catalog types in
Types_Catalog.pod, meaning essentially top-down order. All the grammar
elements which are part of the "value" sub-language will remain
declared prior to all the elements which are not.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Fixed a fossil from changes
in v0.68.0 by renaming the "TINY" of the main pod section "MULDIS D
STANDARD TINY PRAGMAS" to "STANDARD".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Demoted the routine
invocation alternate syntaxes to an optional extension of the STD
dialects, so more minimal Muldis D implementations may now omit that
significant complexity if they want, though non-minimal implementations
should support them. Moved the main pod section "MULDIS D STANDARD
DIALECT PRAGMAS" upwards to be just before the main pod section
"FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS", and the latter is
now subservient to the former. Fleshed out the moved PRAGMAS section
with, and updated the "LANGUAGE NAME" pod section to mention, a newly
first pragma "with_rtn_inv_alt_syn"; this pragma must now be explicitly
activated in the language declaration of Muldis D code for that code to
make use of the routine invocation alternate syntaxes, whereas before
code could use them by default. In the "GENERIC VALUE EXPRESSIONS"
main pod section, refactored the "expr" node definition by splitting
that into itself and the new "expr_core_options" node, which has all of
the old options of "expr" except for "func_invo_alt_syntax"; so now the
effect of activating the new pragma is to redefine the "expr" node to
add "func_invo_alt_syntax" as an option.
* (PTMD_STD.pod) Updated the "DEPOT DECLARATION" main pod section to
flesh out the grammar some more, so it now basically covers all the
syntax to declare whole depots, subdepots, and packages, but not yet
materials or any of what goes inside materials. There were no
descriptive text additions to describe that grammar nor examples nor
any corresponding additions in HDMD_Perl[6|5]_STD.pod. This "DEPOT
DECLARATION" stuff may be rewritten next update anyway.
2009-09-12 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.88.0 is released on CPAN as
Muldis-D-0.88.0.tar.gz.
* This release features the elimination of the "bootloader" concept,
namely Muldis D code that doesn't live in a depot (and that isn't a
simple value literal). You must now use in-depot code to do whatever
you would have used a "bootloader" for. For your "main program" in a
non-hosted Muldis D environment, you now put that code in a procedure
of a depot and mark that procedure as being a stimulus-response rule
(trigger) where the stimulus is the mounting of its host depot. Now to
make a database restore script, you simply have another depot holding
all the database's schema and data, and that has a procedure which will
clone itself to another database; similarly, doing a whole database
dump / backup works in exactly the same manner. Since a possible
physical representation of a depot is simply a Muldis D source code
file, you can still write code as normal even if you're actually
writing a depot, same as you'd write a library in a gen purp language.
* (Basics.pod) Formatting typo fix, other minor fixes.
* (Basics.pod) Renamed the "triggered routine" concept (analogous to
general case of a SQL trigger) to "stimulus-response rule", and updated
any referring documentation to no longer say that the concept is
unsupported for the forseeable future; in fact it now is officially
supported (and required for the featured change item), though its
details are not yet specified. The updated docs were all in the
"ROUTINES" pod sub-section "Other Matters", and the "TRANSACTIONS AND
CONCURRENCY" main pod section.
* (Basics.pod) In the "ROUTINES" main pod section, split up the
routine kind hierarchy diagram into 2, with all the specific-API
functional kinds being separated out, the reason being that their
distinction is orthogonal to the function/inner-function distinction.
* (Basics.pod) In the "ROUTINES" main section, removed the
"bootloader_exclusive" and "bootloader" routine kinds and part of the
"Other Matters" pod sub-section. Updated the "Type Safety" pod
sub-section of "TYPE SYSTEM". Multiple updates to the "TRANSACTIONS
AND CONCURRENCY" main pod section; for one thing, there are no longer
any transactions that aren't scope bound, except possibly for direct
use by other host languages as an implementation permits. Updated the
"User-Defined Resources" pod sub-section of "RESOURCE MODULARITY AND
PERSISTENCE". Updated the "User-Defined Entities" and "Time-Varying
Topic Namespaces" pod sub-sections of "ENTITY NAMES".
* (Routines.pod) Removed the whole pod main section "SYSTEM-DEFINED
GENERIC BOOTLOADER EXCLUSIVES", and all 3 bootloader_exclusive routines
"[start|commit|rollback]_trans".
* (Types_Catalog.pod) The catalog type "SysProcSet" (and hence the
"procedures" attribute of the "System" catalog type) is no longer used
to specify bootloader exclusive routines.
* (Routines_Catalog.pod) Gutted the main description text of the main
pod section "PROCEDURES FOR BOOTSTRAPPING A MULDIS D PROGRAM OR
DATABASE" as the procedures are no longer mainly just to allow
bootloaders to work at all, but now they are simply convenient ways to
do data definition in normal procedures.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) The root grammar token for
the entire dialect is renamed to "Muldis_D" from "bootloader", and it
is now just a "language_name" plus a "value" or "depot", rather than
also having a third option of a sequence of "boot_stmt". The main pod
section "BOOTLOADER" was renamed to "START" and had a number of
updates. The main pod section "BOOTLOADER STATEMENT" was removed
entirely. There were a number of related smaller updates in various
sections. In PTMD_STD.pod, large updates to the "GENERAL STRUCTURE"
main pod section.
* (Muldis_D_PDAFP_200807_updated.xul, BBEdit_LM_Muldis_D.plist)
Updates corresponding to recent spec changes.
2009-09-03 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.87.0 is released on CPAN as
Muldis-D-0.87.0.tar.gz.
* (HDMD_Perl[6|5]_STD.pod) Fixed fossils from v0.73.0 regarding
normalization of the basic format of "func_invo_alt_syntax"/"op" nodes;
some example code in "Generic If-Else Expressions" wasn't updated.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the concrete syntax
for generic scalar literals to make the possrep name optional; if a
generic scalar literal doesn't have an explicit possrep name, it is now
interpreted as if it had an explicit possrep name that is the empty
string, which is often the name that possreps have when there is just
one of them in a scalar type.
* (Basics.pod) Introduced a new mnemonic for Muldis D where in some
contexts the characters "$", "%", "@" specifically represent scalars,
tuples, relations respectively. This is useful considering the various
operators that come in different flavors for tuples/relations, say, but
have conceptually identical syntax, and need distinguishing actual
syntax because Muldis D's standard concrete syntaxes won't determine
which one to use by the types of the arguments. This particular
mneumonic is based on Perl, that uses the 3 characters to represent
scalars/objects, hashes/mappings, and arrays/sequences respectively.
Also, the mnemonic of doubling some things up to represent relation
versions where singles of the same are tuple versions, is now gone.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Routines.pod) Updated the
concrete syntax for all postcircumfix operators such that the
tuple-specific and relation-specific versions are now distinguished by
a leading "%" and "@" respectively, and both use just a single brace
pair, rather than distinguishing being on a single brace pair versus a
double one respectively. So for example, tuple/relation rename() now
looks like "%{<-}"/"@{<-}" rather than "{<-}"/"{{<-}}". Similarly, the
wrap()-concerning and group()-concerning operators are now
distinguished by using a single "%" and "@" between the braces
respectively, rather than distinguishing with a single versus a double
"@". So for example, relation wrap()/group() now looks like
"@{%<-}"/"@{@<-}" rather than "{{@<-}}"/"{{@@<-}}".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Routines.pod) Added special
alternate syntax for scalar "projection" (extracting a subset of a
scalar's possrep's attributes as a tuple) as 2 new postcircumfix ops
"${}", "${!}"; an example of use being "$birthday${date;year,month}".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Routines.pod) Added special
alternate syntax for accessing individual scalar possrep and tuple
attributes, specifically over the 2 "Core.[Scalar|Tuple].attr"
functions as 2 new postcircumfix ops ".${}" and ".%{}"; examples of use
are "$birthday.${date;day}" and "$pt.%{city}".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Array.pod) Added special
alternate syntax for accessing "Array" elements, either individual
elements or array slices, specifically over the 2 "Array.[value|slice]"
functions as 2 new postcircumfix ops ".[]" and "[..]"; examples of use
are "$ary.[3]" and "$ary[10..14]".
* (Basics.pod, Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod)
Updated the "terse pseudo-variable syntax" feature extension of DBMS
entity names so that it is more restrictive, such that in most
situations it may now only be used to address attributes of tuple (or
database) typed entities, and no longer also attributes of scalar
possreps or relations. This added restriction is in place for
practical reasons of Muldis D syntax being more strongly typed, such
that it is possible to know at parse-time whether each attribute access
is for a scalar or tuple or relation, and so both it is easier to
implement Muldis D and easier to understand at a glance what Muldis D
code is doing, even if the system catalog representation of the code is
a bit more verbose due to requiring more explicit function calls. In
Basics.pod, updated the 2 pod sub-sections "Terse Pseudo-Variable
Syntax" and "Referencing Data Types". In Types_Catalog.pod, updated
the description of the "AccExprNodeSet" catalog type. In PTMD_STD.pod,
updated the description of "NameChain_payload" grammar nodes and
"accessor" grammar nodes; in all 3 STD files, updated the example code
comments for "accessor" grammar nodes.
* (Muldis_D_PDAFP_200807_updated.xul) Updates corresponding to recent
spec changes.
2009-09-02 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.86.0 is released on CPAN as
Muldis-D-0.86.0.tar.gz.
* (Basics.pod, PTMD_STD.pod, Input_Method_Muldis_D.cin) Fixed fossils
from v0.85.0 re '!' usage.
* (Routines.pod, PTMD_STD.pod, Input_Method_Muldis_D.cin) Removed "<>"
as an alternate concrete syntax for "≠"; now only "!=" is an alternate.
* (HDMD_Perl6_STD.pod, Muldis_D_PDAFP_200807_updated.xul) In
accordance with the latest Perl 6 spec (an update on 2009.08.29),
updated the HDMD_Perl6_STD code examples to reflect that you now use
"/" to select a Perl 6 "Rat" in terms of 2 "Int", where you used to use
"div" to do that.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In the "GENERIC VALUE
EXPRESSIONS" main pod section, made the rules for the "named_expr"
grammar node more lax such that now it is valid for *any* other "expr"
node to be named by it, including another "named_expr"; in such a case
as this, or when naming an "expr_name" node, an "AccExprNodeSet" tuple
is now defined as what it parses to, and we have a simple node alias.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In the "GENERIC VALUE
EXPRESSIONS" main pod section, added new pod sub-section "Generic
Expression Attribute Accessors", featuring the new grammar node
"accessor", whose initial flavor is "acc_via_named". This addition is
part of a grammar refactor that also features the "expr_name" node
being simplified to just take a "Name" payload, and "acc_via_named" now
handles the "NameChain" payload that "expr_name" used to handle. Now
"expr_name" just references named expression nodes or parameters etc,
and no longer drills into their attributes; drilling is now just the
purvue of "accessor". The refactor also eliminated the distinct
"decl_expr_name" as "named_expr" now uses "expr_name" instead. In
PTMD_STD, the "acc_via_named" grammar is identical to the old
"expr_name" and so this change is backwards compatible. However, in
HDMD_Perl[6|5]_STD, a small backwards-incompatible change was
introduced, such that the first element of every "accessor" node is
"$." rather than "$" which "expr_name" uses; but there was no older
example code which did drilling, so no update was necessary.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) In "Generic Expression
Attribute Accessors", added new "accessor" grammar node flavor
"acc_via_anon", which provides the new feature that attributes can now
be accessed/aliased of anonymous expression nodes (not just explicitly
named nodes), such as one would expect to be able to do in a
programming language; for example you can now say "inn.tuple_res_func(
$arg ).quux_attr" (PTMD_STD).
* (Types.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Blob.pod)
Corrected several instances of repeated word typos.
2009-08-29 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.85.0 is released on CPAN as
Muldis-D-0.85.0.tar.gz.
* (HDMD_Perl[6|5]_STD.pod) Updated the "DESCRIPTION" main pod to
boldface the portion saying one should read the PTMD_STD dialect spec
first, since readers may gloss over the introduction and not realize
how essential this is to understanding the Perl-STD dialect specs.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod, Integer.pod) The special
alternate syntax for the integer 'factorial' function is now the 'I!'
postfix rather than the '!' postfix.
* (PTMD_STD.pod, Routines.pod) Added special alternate syntax for the
boolean 'not' function which is the '!' prefix, that complements the 2
'not', '¬' prefix syntaxes. This addition should satisfy something
that many developers would expect to be present, especially since '!'
is already used as a component of many multi-char operator alternate
syntaxes to indicate the negation or complement of something.
* (PTMD_STD.pod, Routines.pod, Text.pod) Added special alternate
syntax, the infix 'not isa', complementing the infix '!isa'. Added
special alternate syntaxes, the infix '!matching', '!like',
complementing the infix 'not matching', 'not like'. Also made a few
other minor PTMD_STD.pod and Routines.pod updates.
2009-08-24 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.84.0 is released on CPAN as
Muldis-D-0.84.0.tar.gz.
* (HDMD_Perl[6|5]_STD.pod) Updated the syntax for "expr_name" and
"named_expr" nodes so that both they are more terse and they more
closely resemble the PTMD_STD syntax for the same nodes; the first
element of each of these nodes is now the character string '$' and
'::=' respectively, rather than 'expr_name' and 'named_expr'. The vast
majority of actual updates were to the code examples using these nodes.
2009-08-20 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.83.0 is released on CPAN as
Muldis-D-0.83.0.tar.gz.
* This distribution has excised its direct external dependency on the
"version" module, which had no practical use to begin with. This
change has no effect on the version number format of the distribution
or documentation files.
* (Routines.pod) Updated the descriptions of 2 otherwise-unaltered
functions to add or update notes about alternate names or symbols that
the function or its operation are known as.
* (Basics.pod, Types_Catalog.pod) Renamed the concept "foreign key" to
"subset constraint". One reason is that the new name is more accurate,
both because it better describes the nature of the constraints (seeing
if all members of one set are in another set) and since these
constraints are defined as a type constraint on a nonscalar type, and
all subjects of the constraint are equally "local". Another reason is
so that all remaining uses of the term "foreign" in Muldis D refer to
entities that are external to the Muldis D language or DBMS
environment, such as other peer languages or remote DBMSs. In
Types_Catalog.pod, renamed the 3 catalog types
"Foreign[|Distrib]KeySet", "FKChildAttrParentAttrMap" to
"[|Distrib]SubsetConstrSet", "SCChildAttrParentAttrMap", and updated
the catalog type "InnerNonscalarType" to rename its 2 attributes
"foreign_[|distrib_]keys" to "[|distrib_]subset_constraints".
* (Types_Catalog.pod) Corrected a mistake in the descriptions of the 2
catalog types "[|Distrib]SubsetConstrSet" concerning the effect of a
subset constraint defined over zero relation attributes.
* (BBEdit_LM_Muldis_D.plist) Updates corresp to recent spec changes.
2009-07-27 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.82.0 is released on CPAN as
Muldis-D-0.82.0.tar.gz.
* (Types_Catalog.pod) Renamed catalog type "AliasExprNodeSet" to
"AccExprNodeSet" and renamed its "original" attribute to "target"; each
tuple of this type represents an "accessor" expr node rather than an
"alias"; also updated the "ExprNodeSet" catalog type to rename its
"alias_exprs" attribute to "acc_exprs".
* (Ordered.pod) Updated the descriptions of 2 otherwise-unaltered
functions to add or update notes about alternate names or symbols that
the function or its operation are known as.
* (Routines.pod, Types_Catalog.pod) Updated each of the 5 functions
"sys.std.Core.[Tuple|Relation].[|cmpl_]wrap",
"sys.std.Core.Relation.unwrap" to swap the canonical order of its 2
"outer", "[|cmpl_]inner" parameters so that the one applying to the
function's result appears first / on the left. Likewise with each of
the 5 functions
"sys.std.Core.Relation.[|cmpl_|un|[cardinality|count]_per_]group" and
its 2 "[outer|count_attr_name]", "[inner|group_per]" parameters. Also
swapped the canonical order of the 2 attributes of the "AttrRenameMap"
catalog type so that "after" comes first / on the left, and updated the
descriptions of the 2 "rename" functions to reflect this change.
* (Routines.pod) Updated the "sys.std.Core.Tuple.unwrap" function to
add a completely superfluous "inner" parameter for no reason other than
to make parity with the "Relation" flavor of that function (and every
other wrap/group/un function, where it is actually needed in the
general case); well that, and it probably helps with
self-documentation, and with developing normalized concrete syntax.
* (PTMD_STD.pod) Fixed a few fossils or other minor errors.
* (PTMD_STD.pod) Small grammar refactor; added new grammar node
"attr_name" which is simply a "Name_payload" and updated the 3 other
nodes "tuple_list", "r_[empty_body|ordered_attr]_payload" to embed the
new node rather than directly the old one.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the main pod section
"FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS", added new pod
sub-section "Simple Postcircumfix Operators", which provides
function-specific concrete syntaxes for 16 more (non-plain-alias)
functions, each of which having 1 special syntax specific to it. In
PTMD_STD, this section introduced the new main node kind
"postcircumfix_op_invo". These are the 16 functions represented:
"sys.std.Core.[Tuple|Relation].rename",
"sys.std.Core.[Tuple|Relation].[projection|cmpl_proj|[|cmpl_|un]wrap]",
"sys.std.Core.Relation.[|cmpl_|un|cardinality_per_]group". The new
special syntaxes use combinations of these: '{', '}', '<-', '@'.
* (Routines.pod) Updated the descriptions of the 16 functions
mentioned in the previous change item to add notes about alternate
names or symbols that the function or its operation are known as.
* (Basics.pod) Updated the main pod section "NOTES ON TEXT CHARACTER
LITERALS" to say that the "@" character is now in use for something, a
sigil used in wrap/group/etc ops, rather than being unused.
* (Muldis_D_PDAFP_200807_updated.xul, Routines.pod) Other small
updates corresp to recent spec changes; in Routines.pod it is with the
description for the relational divide function.
2009-07-15 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.81.0 is released on CPAN as
Muldis-D-0.81.0.tar.gz.
* This release features some refactoring of the system catalog, mainly
to make it less wide and more deep, which incidentally is what release
0.78.0 was mainly doing as well. Benefits of these changes include
that for any formats of the system catalog that are fully
unwrapped/ungrouped as a set of relvars with just scalar attributes,
such as it would likely be when represented by a typical SQL DBMS, the
catalog might require a few orders of magnitude fewer relvars/tables.
Less wide and more deep means that what otherwise might be multiple
relvars/tables with a very similar structure and differing mainly/just
on their extra foreign-key attributes/columns, are now merged into
fewer relvars/tables with simple generalizations of said structures.
* (Types_Catalog.pod, Routines_Catalog.pod) Merged the catalog types
for defining depots with those for defining packages to produce common
catalog types for defining both. In Types_Catalog.pod, merged the 2
main pod sections "TYPES FOR DEFINING [DEPOTS AND SUBDEPOTS|PACKAGES]"
into the 1 main pod section "TYPES FOR DEFINING DEPOTS AND SUBDEPOTS
AND PACKAGES", and merged the 4 catalog types "[Depot|Package]" and
"[Dep|Pkg]MaterialSet" into the 2 catalog types "DepotOrPackage" and
"MaterialSet". The new "DepotOrPackage" has the same 5 attributes at a
high level that "Depot" had, a proper superset of the 3 that "Package"
had, and its 2 "[subdepots|packages]" attributes simply are empty sets
when defining a package. The "PackageSet" type was modified to remove
its "package" attribute, so it is now structurally identical to the
"SubdepotSet" type, and now just declares the existence of packages not
their contents. The new "MaterialSet" type has 6 attributes where the
old analogous types each had 4; 3 of these are identical between each
of the 3 old/new types, ["name", "comment", "material"]; 1 of these,
"is_public" is in both the new and Pkg, and is changed from a "Bool" to
a "maybe_of.Bool"; 1 of these is the "parent" in Dep and is renamed to
"subdepot" in the new; "MaterialSet" also has 1 attribute that neither
of Dep|Pkg had, which is "package", that serves a similar purpose to
"subdepot" for package materials. In Routines_Catalog.pod, updated the
"create_package" procedure to remove its "package" parameter, and made
some updates to the descriptions of a few related procedures.
* (Types_Catalog.pod) Refactored the inner types such that rather than
embedding special-purpose "InnerFuncBody" associated with implicit
function headings, they now just make use of actual named inner
functions with explicit headings, which the inner types refer to by
declaration name; all of the parts of what was an inner type still must
have a common (outer) material. Also deleted the catalog type
"sys.std.Core.Type.Cat.ConstraintSet", which is no longer useful since
all constraint functions now have names by virtue of being actual inner
functions. The updated 7 catalog types are: "Possrep[|Map]Set",
"Inner[Scalar|Nonscalar|Union|Restr]Type", "VirtualAttrMapSet".
* (Types_Catalog.pod) Split 3 catalog types 2 ways each, with some
renaming, where the members of each post-split pair are initially
clones of their original; "NameExprMap" became itself plus
"IISArgVarMap", "IfThenMap" became "IfThen[Expr|VarStmt]Map",
"WhenThenMap" became "WhenThen[Expr|VarStmt]Map". Updated attr types
of 5 other catalog types to use either of the 5 new type names:
"[IfElse|GivenWhenDef][Expr|Stmt]NodeSet", "ImpInvoStmtNodeSet". Given
that, post the above changes, all of the 6 post-split catalog types
except "NameExprMap" are used by exactly 1 other type, moved the
definitions of said 5 post-split types to be just after their users;
moved them from the "SIMPLE GENERIC NONSCALAR TYPES" main pod section
to the "TYPES FOR DEFINING INNER ROUTINE BODIES" main pod section.
* (Types_Catalog.pod) Fixed all catalog type attributes that held
names of procedure statement nodes so that the types of said attributes
are now "Name" rather than "NameChain". Using a "NameChain" on a
statement node name never really made sense as it is never referencable
outside its own lexical context and, unlike the expression node it was
modelled after, it doesn't represent a value nor have a type so it
can't be drilled into. These 8 catalog types had one or more
attributes so fixed:
"[Leave|Compound|IfElse|GivenWhenDef|Iterate|Loop]StmtNodeSet",
"[If|When]ThenVarStmtMap". Also updated the "IISArgVarMap" type to
rename its 2 attributes from "[name|expr]" to "[arg|var]".
* (Types_Catalog.pod) Refactored the catalog types for defining
expression nodes so that the ability to drill into an expression node
or parameter etc value with the "NameChain" shorthand is now restricted
to being used with just one kind of expression node, and all other
expression node kinds can now only use "Name" values to reference child
nodes. Added new catalog node type "AliasExprNodeSet" for defining
expression nodes that just alias or drill into attributes of other
nodes or parameters, and updated the "ExprNodeSet" type to add a new
"alias_exprs" attribute of the new type. Then updated these 8 catalog
types whose attributes held names of expression nodes so that the types
of said attributes are now "Name" rather than "NameChain":
"[Set|Ary|Bag]SelExprNodeSet", "[IfElse|GivenWhenDef]ExprNodeSet",
"[If|When]ThenExprMap", "NameExprMap".
* (Types_Catalog.pod) Updated the "TYPES FOR SPECIAL ENTITY
REFERENCES" main pod section in regards to when two distinct selections
of "MaterialRef" values would produce identical or distinct values, and
how currying affects identity. The new version is more DWIM.
2009-07-06 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.80.0 is released on CPAN as
Muldis-D-0.80.0.tar.gz.
* This release features the extension of function reference types so
they also represent pre-bound parameters, which gives Muldis D both
proper closure support like that of other languages, as well as proper
currying support like that of other languages. A consequence of this
is that all 50+ explicit "assuming" parameters are now removed from the
system-defined routines that took functional closure arguments, and so
those routines are now more like corresponding ones in other languages.
* (Types_Catalog.pod, Routines_Catalog.pod) Renamed the first word of
the title of the main pod section "FUNCTIONS FOR SPECIAL ENTITY
REFERENCE DEFAULT VALUES" to "ROUTINES" and added new procedure
"sys.std.Core.Cat.noop" which has no params and doesn't do anything.
Updated the "ImpRef" type definition so that a ref to "noop" is its new
default value (but the default of "UpdRef" is still "assign").
* (Routines.pod) Updated the procedure "try_catch" to make the "catch"
parameter optional, so by default an exception thrown in "try" is
simply a no-op over all. Also renamed the 4 parameters
"[try|catch]_[updating|assuming]" to "[try|catch]_[upd|ro]_args". Also
"try_catch" now works like "inp_invo" in how it invokes imperatives;
each "*args" attribute now maps to a distinct parameter rather than the
invoked simply having 2 Tuple params named "updating" and "assuming".
* (Basics.pod) Updated the "ROUTINES" main pod section to say that
conceptually Muldis D routines actually have 1 or 2 Tuple-typed
positional params and the named attributes of those Tuple params are
the named params that the routines officially have; sys-def funcs like
"func_invo" expose this nature since you pass callee args in a Tuple.
* (Routines.pod) Fixed the "func_invo" description to not use the word
"curried" since that isn't what "func_invo" conceivably does, or at
least not with the same meaning as any other function doing "curried".
* (Basics.pod) Mainly in the "ROUTINES" main pod section of
Basics.pod, updated all 4 named routine kinds which used to have
exactly N parameters and one was named "assuming", so to have instead
at least N-1 parameters and the explicit "assuming" was removed in
favor of optional normal parameters; said 4 routine kinds are:
"order_determination", "value_[filter|map|reduction]". More broadly
speaking, the concept of "currying", that is using any "assuming"
parameters that system-defined Muldis D routines may have, is now the
same as in other common programming languages, where each attribute of
an "assuming" Tuple will bind to an actual same-named parameter of the
routine rather than the whole "assuming" binding to a single
"assuming"-named param. This change item doesn't include updating the
descriptions of sys-def routines that use currying, because subsequent
change items remove the need.
* (Types_Catalog.pod, Routines.pod) In Types_Catalog.pod, updated the
"TYPES FOR SPECIAL ENTITY REFERENCES" main pod section to say that
"MaterialRef" types can now represent more info than a name to invoke,
but with "FuncRef" it can now also represent runtime-context pre-bound
parameters, and so a "FuncRef" is now more like a full-blown closure.
In Routines.pod, added new function "sys.std.Core.Control.curried_func"
which curries a "FuncRef" to derive another "FuncRef" with fewer
parameters. Now to keep things simple, currently imperative routines
can not be curried; that might be supported in the future if a good way
can be found for users to curry updateable parameters.
* (Types_Catalog.pod, Routines.pod) While order_determination
functions in general can now have 3+ parameters, the ones that are
baked into scalar root types as their type-default order algorithms
must instead have exactly 4 parameters, the 4th being a "misc_args"
tuple; related to this, updated the "sys.std.Core.Scalar.order"
function to rename its "assuming" parameter to "misc_args".
* (Tuple.pod) Updated the order_determination function
"sys.std.Tuple.order_by_attr_names" to replace its "assuming" parameter
with an "order_by" parameter, the latter previously having been
supplied as the sole attribute of the former.
* (Ordered.pod) Updated every one of the 12 functions to remove its
"assuming" parameter. Any situation where said parameter might have
been used can now curry the ord-det-func instead; this also means that
for any customizable scalar type-default ODF, the "func" parameter now
would have to be explicitly given.
* (Routines.pod, Relation.pod, Set.pod, Array.pod, Bag.pod,
Counted.pod) Updated every one of the 37 remaining routines with a
"[|[summ|ord|restr|subst|exten]_]assuming" parameter to remove that
parameter. The number of updated routines by file were: 8 in
Routines.pod, 15 in Relation.pod (2 of those with 2 params each
removed), 3 in Set.pod, 5 in Array.pod, 2 in Bag.pod, 4 in Counted.pod.
* (Routines.pod, Bool.pod, PTMD_STD.pod) Demoted the function
"sys.std.Core.Bool.xor" from the language core into the "Bool"
extension and it is now named "sys.std.Bool.xor". Also, any places
where both "xnor" and "xor" are mentioned, they are now in that order.
* (Routines.pod, Bool.pod) Updated the descriptions of 4
otherwise-unaltered functions to add or update notes about alternate
names or symbols that the function or its operation are known as.
* (Routines.pod, Bool.pod) Added 2 functions
"sys.std.Core.Bool.[all|any]" which are simple aliases for the 2
"sys.std.Core.Bool.[and|or]". Added a complement of 9 new functions (8
standalone plus 1 alias), all in the "sys.std.Bool.\w+" namespace:
"not_all", "none", "not_any", "[|not_][one|exactly]", "true", "false".
All 9 are N-adic, taking a set or bag of Bool inputs; the 2 "exactly"
also take a NNInt input; the first 7 result in a Bool and the last 2 in
a NNInt. The purpose of these 11 new functions is to be the basis for
easier specification of a variety of common constraints, including
"existential quantification" and "universal quantification".
* (Conventions.pod, BBEdit_LM_Muldis_D.plist,
Input_Method_Muldis_D.cin) Various minor updates and fixes.
2009-06-16 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.79.1 is released on CPAN as
Muldis-D-0.79.1.tar.gz.
* Forked the slideshow "archives/Muldis_D_PDAFP_200807_sa.xul" into
itself, which remains unchanged, and the new file
"archives/Muldis_D_PDAFP_200807_updated.xul", which has been modified
just enough to bring it into compliance with all the Muldis D spec
changes made since release 0.43.0 (when "_sa" was frozen). The most
significant improvements in "_updated" is that all the concrete Muldis
D code examples were rewritten into ones with the same semantics but
that are actual semi-specced Muldis D code rather than pseudo-code;
especially prominant is that the new code's size is 80-90% smaller than
before, and in the examples comparing Muldis D to SQL, the Muldis D
code was generally just half the size of the SQL code, so being less
verbose than SQL rather than more. And so, from now on,
"Muldis_D_PDAFP_200807_updated.xul" will continue to be updated with
each Muldis D release when it otherwise becomes incorrect, and so it
should remain one of the best introduction materials to Muldis D.
2009-06-13 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.79.0 is released on CPAN as
Muldis-D-0.79.0.tar.gz.
* (Types_Catalog.pod) Removed the catalog type
"sys.std.Core.Type.Cat.OrdDetFuncNameChain", which had only been used
for the first 3 releases of its existence (0.36-38.0), and since
release 0.39.0 only the "OrdDetFuncRef" type was used instead of it.
* (Types_Catalog.pod, Types.pod, PTMD_STD.pod) Added new reference
root catalog type "sys.std.Core.Type.Cat.MaterialRef" and redefined the
4 existing "sys.std.Core.Type.Cat.[Func|OrdDetFunc|Proc|Type]Ref"
catalog types as enumeration types that are proper subtypes of the new
one, rather than being distinct root types of their own. The 4
redefined types are practically exactly the same as before except that
the default value of "TypeRef" is now "Universal" rather than "Bool",
reflecting the default of the "InnerRestrType" and "Material" catalog
types, and "MaterialRef" also has the same default. Corresponding to
the reorg, merged the 4 nonscalar catalog types
"sys.std.Core.Type.Cat.[Func|OrdDetFunc|Proc|Type]RefSelExprNodeSet"
into the 1 "sys.std.Core.Type.Cat.MaterialRefSelExprNodeSet", and
merged the corresponding 4 attributes of the "ExprNodeSet" catalog type
into 1. Also updated the "special_types" attribute of the "System"
catalog type to reflect just the "MaterialRef" type and not the 4 old
reference types that are now its subtypes. In Types.pod, updated the
definition of the "Reference" type to say its default value is now
"Universal", following the "TypeRef" change. In PTMD_STD.pod, updated
the "Library Entity Reference Selector" pod sub-section to reflect the
rearranging of the reference types.
* (Types_Catalog.pod, Routines.pod, Basics.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Renamed the 2 catalog types
"sys.std.Core.Type.Cat.Proc[Ref|InvoStmtNodeSet]" to the 2
"Imp[Ref|InvoStmtNodeSet]" since they reference any imperative routine,
not just a procedure. Also renamed the "ImpInvoStmtNodeSet" attribute
"procedure" to "imperative", and renamed the "StmtNodeSet" attribute
"proc_invo_stmts" to "imp_invo_stmts". Also renamed the
"sys.std.Core.Control.proc_invo" procedure to "imp_invo" and renamed
its "procedure" parameter to "imperative"; this routine also now can
invoke any imperative, even an updater. In the STD files, renamed the
"proc_ref" node kind to "imp_ref".
* (Types_Catalog.pod, Routines.pod) Added new catalog type
"sys.std.Core.Type.Cat.UpdRef", a proper subtype of "ImpRef", and
updated the updater "sys.std.Core.Control.upd_invo" to use it as the
type of its "updater" parameter.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Corrected examples fossil.
* (Relation.pod, Array.pod) Updated each of the 4 functions
"sys.std.Relation.[rank|limit]",
"sys.std.Array.[|limit_of_]Array_from_wrap" to change the declared type
of its "ord_func" parameter from "FuncRef" to "OrdDetFuncRef".
* (Basics.pod) In the "ROUTINES" main pod section, some pod
reformatting where the group of list items was changed to a group of
pod sub-sections; each list item title became a level-2 pod heading;
also the text that followed the old list got a level-2 heading of its
own, "Other Matters".
* (Basics.pod, Types_Catalog.pod, Routines.pod, Set.pod) In the
"ROUTINES" main pod section, renamed the routine kind "type_default" to
"named_value" and made its description more general, though its actual
structure (any niladic function) is unchanged. Then updated any
references to that routine kind. Then updated the
"sys.std.Set.Maybe.nothing" function description to explicitly say it
is a "named_value" function.
* (Tuple.pod, Relation.pod, Types.pod, Basics.pod) Added 3 new
"named_value" functions "sys.std.Tuple.d0", "sys.std.Relation.d0c[0|1]"
which result in all 3 of the nonscalar values with zero attributes,
which have special names; also tweaked docs about said special names.
* (PTMD_STD.pod, BBEdit_LM_Muldis_D.plist) Added special literal
syntax to the "Tuple" and "Relation" node kinds, similar to what exists
for "Maybe", so the plain barewords "d0", "d0c0", "d0c1" are now
nonscalar GCVLs by themselves, like "nothing" or "∅" are. Note that
this feature is in PTMD_STD alone; the Perl-STD dialects don't have it.
* (Routines.pod) Updated the "sys.std.Core.Relation.summary" function
to make it more standardized relative to other system-defined
conceptually monadic mapping functions; the function given to its
"summ_func" parameter must now have a single varying parameter named
"topic" taking a binary tuple with "summarize" and "per" attributes,
rather than having 2 varying parameters named "summarize" and "per".
* (Relation.pod) Fixed 3 instances of a fossil: Updated each of the 3
updaters "assign_subst[itution|_in_[restr|semijoin]]" to add a single
parameter "[|subst_]attr_names". The corresponding 3 non-"assign_"
functions had said parameter added in release 0.59.0 and the 3
"assign_" updaters should have gained them too, but didn't.
* (Basics.pod, Types_Catalog.pod, Routines_Catalog.pod) In the
"ROUTINES" main pod section of Basics.pod, added 3 more routine kinds
named "value_[filter|map|reduction]", which describe all the kinds of
closures that system-defined functions take as arguments, besides the
single generic "func_invo"; each has either a single "topic" parameter
or a "v1"+"v2" parameter, and each has an "assuming" parameter. Added
3 catalog reference types
"sys.std.Core.Type.Cat.Val[Filt|Map|Red]FuncRef", each of which points
to just one kind of function. In Routines_Catalog.pod, added new main
pod section "FUNCTIONS FOR SPECIAL ENTITY REFERENCE DEFAULT VALUES"
which defines 3 new catalog functions
"sys.std.Core.Cat.[[pass|map_to]_topic|reduce_to_v1]" whose main
purpose is that refs to them are the default values of the 3 new types.
* (Routines.pod, Relation.pod, Set.pod, Array.pod, Bag.pod,
Counted.pod) Updated 1 or 2 parameters each of 31 routines to change
each of the parameter's declared types from "FuncRef" to one of the new
3 kinds. In 9 routines, replaced 1 param type with "ValFiltFuncRef":
"sys.std.Core.Relation.[|assign_][restriction|cmpl_restr]",
"sys.std.Core.Relation.restr_and_cmpl",
"sys.std.Relation.[|assign_][|static_]subst_in_restr]". In 14
routines, replaced 1 param type with "ValMapFuncRef":
"sys.std.Core.Relation.[|assign_]extension",
"sys.std.Core.Relation.summary",
"sys.std.Relation.[classification|map]",
"sys.std.Relation.[|assign_]subst[itution|_in_[restr|semijoin]]",
"sys.std.Relation.outer_join_with_exten",
"sys.std.Counted.counted_[map|substitution]". In 10 routines, replaced
1 param type with "ValRedFuncRef":
"sys.std.[Relation|Set|Array|Bag].[|maybe_]reduction",
"sys.std.Counted.counted_[|maybe_]reduction".
* (Basics.pod, Types_Catalog.pod, BBEdit_LM_Muldis_D.plist) Various
minor updates and fixes.
2009-06-09 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.78.0 is released on CPAN as
Muldis-D-0.78.0.tar.gz.
* This release features a refactoring of the system catalog types and
routines concerning types for defining "outer" routines and types, such
that 13 catalog types were merged into 3, and 16 catalog routines were
merged into 4, and in other types 8 attributes were merged into 2; this
had the side-effect of making Types_Catalog.pod about 7K lighter, and
Routines_Catalog.pod about 2K lighter.
* (Types_Catalog.pod) Multiple updates of the catalog types for
defining data types, so to help Muldis D code be less verbose. With
the "PossrepSet" type, updated its "constraint" attr's declared type to
be a Maybe of its prior type; a programmer may now leave that attribute
undefined, and the semantics are as if they defined a function that
unconditionally resulted in true. With the 3 types
"Inner[Scalar|Nonscalar|Restr]Type", updated each of the total of 4
attrs "default[|_tuple|_relation]" by changing its declared type to be
a Maybe of its prior type; a programmer may now leave that attribute
undefined, and the semantics are as if they either picked the same
value as the base type, if defining a subtype, or they picked a value
with all attributes being their declared types' default values, if
defining a base type.
* (Types_Catalog.pod) Renamed the main pod section "TYPES FOR DEFINING
ROUTINE HEADINGS" to "TYPES FOR DEFINING INNER ROUTINE HEADINGS". Then
merged the 2 main pod sections "TYPES FOR DEFINING [ROUTINE BODIES|DATA
TYPES]" into the 1 main pod section "TYPES FOR DEFINING ROUTINES AND
DATA TYPES" and placed the post-merge section just prior to the renamed
section. No changes to the catalog types themselves in this chg item.
* (Types_Catalog.pod) Merged the 5 catalog data types
"sys.std.Core.Type.Cat.[[Func|Upd|Proc]Body|Type|InnerTypeSet]" into
the 1 catalog data type "sys.std.Core.Type.Cat.Material". The new type
has a union of all the relation-typed attributes of the 5 old types,
the 7 "inner_[func|upd|proc|[sca|nonsca|uni|restr]_type]s". The new
type also introduces a design change by eliminating the "main_body"
attribute of the 3 old "Body" types; now, a main routine is always
represented by an inner routine of the same kind, which must have the
empty string as its name. Further to that design change, while the old
3 types "[Func|Upd|Proc]Body" did not include the definition of the
main routine's heading and users of them had to pair a "Body" value
with a corresponding "[Func|Upd|Proc]Body" value, the new "Material"
internalizes the "Head" and so defines a whole routine sans name
internally, same as the old "Type" defined a whole type sans name, the
latter also being what "Material" still does.
* (Types_Catalog.pod) Updated all the other catalog data types that
embedded the old data types which became "Material" so to use that new
type instead. Merged the 8 old data types
"sys.std.Core.Type.Cat.[Dep|Pkg][Func|Upd|Proc|Type]Set" into the new 2
data types "sys.std.Core.Type.Cat.[Dep|Pkg]MaterialSet"; where each of
the old types had either the 2 attributes "head"+"body" or the 1
attribute "type", the new types have just the 1 attribute "material".
Also updated the 2 data types "sys.std.Core.Type.Cat.[Depot|Package]"
so that in each, their 4 attributes
"[functions|updaters|procedures|types]" were merged into the 1
attribute "materials". Also updated the 1 data type
"sys.std.Core.Type.Cat.SysTypeSet" to change the declared type of its
"type" attribute from "Type" to "Material".
* (Routines_Catalog.pod) Updated all the catalog routines that worked
with the old data types which became "Material" so to work with that
new type instead. Merged the 16 old procedures in the
"sys.std.Core.Cat.\w+" namespace named
"[create|drop]_[depot|package]_[function|updater|procedure|type]" into
the 4 new "[create|drop]_[depot|package]_material" procedures.
* (Set.pod, Bag.pod) Added 4 functions where each is an alias for
another function. The 4 "sys.std.[Set|Bag].value_is[|_not]_member"
alias the 4 "sys.std.[Set|Bag].has[|_not]_member".
* (Text.pod, Set.pod, Bag.pod) Updated the descriptions of 6
otherwise-unaltered functions to add or update notes about alternate
names or symbols that the function or its operation are known as.
* (PTMD_STD.pod) Within the pod sub-section "Simple Non-symmetric
Dyadic Infix Operators", added function-specific concrete syntaxes for
8 more functions, having 1 special syntax each: "S∈", "S∉", "S∋", "S∌",
"B∈", "B∉", "B∋", "B∌"; none of these has a code example.
2009-06-06 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.77.0 is released on CPAN as
Muldis-D-0.77.0.tar.gz.
* This release features a rough cut (that might have introduced a few
subtle mistakes) of a mass renaming of some Muldis D type categories as
well as corresponding system-defined maximal types, so to make the
documentation simpler, easier to understand, and less ambiguous or more
correct. It concerns the pairs of concepts or types where one had a
"quasi-" prefix and the other didn't; the concepts and types with a
"quasi-" prefix were renamed to lose that prefix and otherwise be the
same; the counterparts that didn't have the prefix gained a different
prefix, "dh-", or "deeply homogeneous". This release makes no changes
at all to the specified language semantics or features, but just to its
syntax; what you may actually do is the same as before. This release
has no file renames/adds/removes; just changes to file contents.
* (Routines.pod, Tuple.pod, Relation.pod, Set.pod, Array.pod, Bag.pod,
PTMD_STD.pod, Basics.pod, Types_Catalog.pod, Ordered.pod, Counted.pod)
Renamed all "sys.std.Core.Q[Scalar|Tuple|Relation].\w+" entities to
"sys.std.Core.[Scalar|Tuple|Relation].\w+", and all
"sys.std.Q[Tuple|Relation|Set[|.QMaybe]|Array|Bag].\w+" entities to
"sys.std.[Tuple|Relation|Set[|.Maybe]|Array|Bag].\w+". This is a
simple reversal of part of release 0.54.0.
* (Types.pod, Basics.pod, Types_Catalog.pod) Removed the
system-defined type "sys.std.Core.Type.Remnant", which is not actually
useful, and has not actually been in use. But the concept "remnant
type" has been retained since it definitely is useful; its just that
any maximal type specific to remnant types must by necessity have the
same value set as the "Universal" type, so that can be used anywhere
"Remnant" would conceivably have been. Also removed the system-defined
type "sys.std.Core.Type.ScaTupRel", which hasn't been in use since
release 0.55.0 made any prior uses of it use "Universal" instead. In
Types.pod, removed the main pod section "SYSTEM-DEFINED REMNANT TYPES".
In Basics.pod, also clarified that every "remnant" type is a proper
subset of "Universal", not just a subset.
(Types.pod, Basics.pod, Types_Catalog.pod, Routines.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod, Tuple.pod, Relation.pod, Set.pod, Array.pod,
Bag.pod, Counted.pod, Ordered.pod, Integer.pod, Blob.pod, Rational.pod,
Temporal.pod, Spatial.pod) In Types.pod, renamed 16 types, in the
"sys.std.Core.Type.\w+" namespace: the 8
"[Scalar|Tuple|Relation|Set|Maybe|Single|Array|Bag]" to
"DH[Scalar|Tuple|Relation|Set|Maybe|Single|Array|Bag]" and the 8
"Q[Scalar|Tuple|Relation|Set|Maybe|Single|Array|Bag]" to
"[Scalar|Tuple|Relation|Set|Maybe|Single|Array|Bag]". In Basics.pod,
updated the pod sub-section "Referencing Data Types" to rename the
"[|quasi_][tuple|relation]_from" typeref syntax to
"[|dh_][tuple|relation]_from" and the
"[|quasi_][set|maybe|single|array|bag]_of" typeref syntax to
"[|dh_][set|maybe|single|array|bag]_of". In all 19 files,
correspondingly updated all references to those types and uses of those
typeref syntaxes. In the 3 STD.pod files, updated all the "value_kind"
that corresponded to the renamed types, renaming them likewise. During
these changes, many references to the prefixless versions of the types,
mainly in system-defined routine signatures, and in example code,
remained prefixless to maintain simpler syntax, and so in appearance
became more generic, though in actuality were still as specific as
before; for example, "bag_of.Int" is in fact just as restrictive as
"dh_bag_of.Int" since the "Int" is a scalar type; the extra "dh_" only
makes an actual difference with nonscalar element types.
* (Basics.pod) Multiple updates to the "TYPE SYSTEM" main pod section.
For each of "scalar","tuple","relation","nonscalar",etc as "foo",
renamed each "foo" concept to "deeply homogeneous foo", and each
"quasi-foo" concept to "foo", and updated the related documentation to
be more readable. Most changes were in the "Type Identification" and
"Distinction of Non-Homogeneous Types from Homogeneous Types" pod
sub-sections; the latter was renamed from "Distinction of Quasi- Types
from Non-Quasi Types". Also an old phrase in the "Distinction ..."
section, "only non-quasi types can be interpreted according to the
relational model, as predicates and prepositions", turned out to be
rather incorrect, and has been excised; this problem is in fact part of
the rationale for the whole renaming this release features. However, a
Muldis D "database" is still as strict as before, only allowing deeply
homogeneous relations as content, since that's much more practical.
* (Types.pod, Routines.pod, Tuple.pod, Relation.pod, Set.pod,
Array.pod, Bag.pod, Basics.pod) Renamed any main pod sections with
"QUASI-/" in their names to remove that text, and renamed any pod
sub-sections with "Q/" in their names to remove that text.
* (Routines.pod, Tuple.pod, Set.pod, Array.pod, Bag.pod, Relation.pod)
Related to the previous changes, to make their names more accurate, 18
routines were renamed from
["sys.std.Core.Scalar.[QTuple_from_QScalar|QScalar_from_QTuple]",
"sys.std.Core.Relation.[QTuple_from_QRelation|QRelation_from_QTuple]",
"sys.std.Tuple.[attr_from_QTuple|QTuple_from_attr]",
"sys.std.Set.QSet_from_[wrap|attr]",
"sys.std.Array.[|limit_of_]QArray_from_wrap[|_by_attr_names]",
"sys.std.Array.QArray_from_attr", "sys.std.Bag.QSet_from_QBag",
"sys.std.Bag.QBag_from_[QSet|wrap|cmpl_group|attr]"] to the same names
but lacking any "Q". This is a reversal of part of release 0.55.0.
* (Basics.pod, Core.pod, Types.pod, Types_Catalog.pod, Routines.pod,
Routines_Catalog.pod, PTMD_STD.pod, Conventions.pod, Ordered.pod,
Tuple.pod, Relation.pod, Set.pod, Array.pod, Bag.pod, Counted.pod)
Since the prefixless types are now the supertypes, purged all instances
of "q/" used before various terms like "scalar" or "tuple"; outside of
titles, there seem to have been about 768 of them.
2009-06-04 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.76.1 is released on CPAN as
Muldis-D-0.76.1.tar.gz.
* This release has the first step of renaming some Muldis D type
categories as well as corresponding system-defined maximal types, so to
make the documentation simpler, easier to understand, and less
ambiguous or less correct; it concerns the pairs of concepts or types
where one has a "quasi-" prefix and the other doesn't. The primary
change now is renaming some files, but otherwise leaving related
changes minimal; the main changes will be done in the next release, so
that it would be easy to diff the important changes without having to
deal with the complexity of simultaneous file name changes.
* (Tuple.pod, Relation.pod, Set.pod, Array.pod, Bag.pod, D.pm,
Core.pod, README) Renamed the 5 files [QTuple.pod, QRelation.pod,
QSet.pod, QArray.pod, QBag.pod] to remove the 'Q' prefix. Updated all
other distro files that referred to the old file names so they refer to
the new ones instead. This is a simple reversal of part of rel 0.54.0.
* (BBEdit_LM_Muldis_D.plist) Missed a few updates in the last release.
2009-06-04 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.76.0 is released on CPAN as
Muldis-D-0.76.0.tar.gz.
* (Basics.pod) Updated the pod sub-section "Terse Pseudo-Variable
Syntax" to clarify that entity names for referencing q/scalar
attributes must drill down through an explicitly named possrep; also
that a q/scalar possrep may be referenced directly as if it were a
q/tuple pseudo-variable.
* (Blob.pod, Text.pod, QArray.pod) Renamed the 3 routines
"sys.std.[Blob|Text|QArray].repeat" to "replication".
* (QSet.pod) Updated each of the 2 functions
"sys.std.QSet.QMaybe.attr_or_[default|value]" to make it N-adic rather
than dyadic; updated the "topic" parameter to make it a
"quasi_array_of.QMaybe" rather than a "QMaybe" (and to make it
optional), and so now the function can now look in any number of QMaybe
values for a value to result in before falling back to the default,
rather than just one. And so the "value" function is now like SQL's
N-adic COALESCE rather than the dyadic version.
* (Routines.pod, QSet.pod) Updated the descriptions of 8
otherwise-unaltered functions to add or update notes about alternate
names or symbols that the function or its operation are known as.
* (Routines.pod, Routines_Catalog.pod, QRelation.pod, Counted.pod)
Some POD reformatting: Updated every routine signature having a param
"FooType $bar_param" with a linebreak between the paired type name and
param name so that each pair is entirely on one line.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the "NameChain" node
payload definition to add a fourth special case where the chain may be
abbreviated, which is that with "lex.topic.attr.etc" chains, the
"topic" may be omitted and the whole chain be prefixed by a period, so
that ".attr.etc" means the same thing. And so common kinds of code
like SQL's "WHERE foo > 1 AND bar < 10" can be written using "$.foo > 1
and $.bar < 10" rather than "$topic.foo > 1 and $topic.bar < 10".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the pod sub-section
"Generic If-Else Expressions", added alternate syntax so that you now
have a choice to spell your "(if $foo then $bar else $baz)" using the
same format "($foo ?? $bar !! $baz)" as the Perl 6 conditional op.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the pod sub-section
"Simple Non-commutative N-adic Infix Reduction Operators", added
function-specific concrete syntaxes for 2 more functions, having 1
special syntax each: "//", "//d"; both have a code example.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the pod sub-section
"Simple Non-symmetric Dyadic Infix Operators", added function-specific
concrete syntaxes for 7 more functions, having 1 special syntax each:
"isa", "!isa", "as", "asserting", "Bx", "Tx", "Ax"; every one but the
"Bx", "Ax" has a code example.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the pod sub-section
"Simple Monadic Prefix Operators", added function-specific concrete
syntaxes for 5 more functions, having 1 special syntax each: "d", "t",
"r", "s", "v"; each one has a code example.
* (BBEdit_LM_Muldis_D.plist) Updates corresp to recent spec changes.
2009-05-28 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.75.0 is released on CPAN as
Muldis-D-0.75.0.tar.gz.
* (Routines.pod, Integer.pod, Blob.pod, Text.pod, Rational.pod,
QRelation.pod, QSet.pod, QArray.pod, QBag.pod, Counted.pod,
Temporal.pod, PTMD_STD.pod, Basics.pod) Renamed these 60 routines to
terser versions of themselves (and with no changes to their namespaces)
mainly for the purpose of making them easier to type:
"sys.std.Core.QScalar.cmpl_projection" -> "cmpl_proj",
"sys.std.Core.Q[Tuple|Relation].[|assign_]cmpl_projection"
-> "[|assign_]cmpl_proj",
"sys.std.Core.Q[Tuple|Relation].[|assign_]static_extension"
-> "[|assign_]static_exten",
"sys.std.Core.QRelation.[|assign_]disjoint_insertion"
-> "[|assign_]disjoint_ins",
"sys.std.Core.QRelation.restriction_and_cmpl" -> "restr_and_cmpl",
"sys.std.Core.QRelation.[|assign_]cmpl_restriction"
-> "[|assign_]cmpl_restr",
"sys.std.Core.QRelation.[|assign_][|semi]difference"
-> "[|assign_][|semi]diff",
"sys.std.Integer.[inc|dec]rement" -> "[inc|dec]",
"sys.std.[Integer|Rational].[|abs_]difference" -> "[|abs_]diff",
"sys.std.Integer.[|maybe_]quotient_and_remainder"
-> "[|maybe_]quot_and_rem",
"sys.std.Blob.length_in_[bits|octets]" -> "len_in_[bits|octets]",
"sys.std.Text.length_in_[nfd_codepoints|graphemes]"
-> "len_in_[nfd_codes|graphs]",
"sys.std.Text.case_folded_to_[upper|lower]" -> "[upper|lower]",
"sys.std.Text.whitespace_trimmed" -> "trim",
"sys.std.Text.is[|_not]_match_using_like" -> "is[|_not]_like",
"sys.std.QRelation.transitive_closure" -> "tclose",
"sys.std.QRelation.[|assign_]static_substitution"
-> "[|assign_]static_subst",
"sys.std.QSet.disjoint_insertion" -> "disjoint_ins",
"sys.std.QArray.has[|_not]_element" -> "has[|_not]_elem",
"sys.std.QBag.difference" -> "diff",
"sys.std.Counted.counted_cmpl_projection" -> "counted_cmpl_proj",
"sys.std.Counted.counted_static_substitution" -> "counted_static_subst",
"sys.std.Counted.counted_difference" -> "counted_diff",
"sys.std.Temporal.[|UTC|Float]Instant.[|abs_]difference"
-> "[|abs_]diff",
"sys.std.Temporal.[|UTC]Duration.difference" -> "diff",
"sys.std.Temporal.Instant.fetch_current_instant"
-> "fetch_curr_instant",
"sys.std.Temporal.[UTC|Float]Instant.fetch_current_[datetime|date|time]"
-> "fetch_curr_[datetime|date|time]".
* (Types.pod) Updated the "Text" type to rename its 1 possrep from
"nfd_codepoints" to "nfd_codes", for consistency with the prior change.
* (Routines.pod) Updated the "sys.std.Core.STDIO.read_Text" routine to
renam its "length_in_graphemes" param to "len_in_graphs", as per above.
* (Routines.pod) Added new "sys.std.Core.QRelation.count_per_group"
function which is a simple alias for "cardinality_per_group".
* (Text.pod) Updated the 2 functions "is[|_not]_like" to explicitly
make the "escape" parameter optional; this was an omission from before.
* (PTMD_STD.pod) Within the pod sub-section "Simple Non-symmetric
Dyadic Infix Operators", added function-specific concrete syntaxes for
2 more functions, having 1 special syntax each: "like", "not like";
these don't have associated code examples yet though.
* (Types_Catalog.pod) Other minor updates.
* (BBEdit_LM_Muldis_D.plist) Updates corresp to recent spec changes.
2009-05-27 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.74.0 is released on CPAN as
Muldis-D-0.74.0.tar.gz.
* (Basics.pod) Added new main pod section "NOTES ON TEXT CHARACTER
LITERALS", just following "NOTES ON TERMINOLOGY", which enumerates all
the characters used (or will be) literally anywhere in the Muldis D
spec, or specifically in the concrete syntax specs, along with their
Unicode character names and a brief description of their use. This is
so that it is easier to recognize said characters when they are seen,
especially since the Unicode standard includes many cases of distinct
characters that visually are nearly identical, so you know
unambiguously what characters the Muldis D spec is actually referring
to. The initial list includes all 94 visible 7-bit ASCII chars plus
'space' plus 41 trans-ASCII characters with known uses plus 11
trans-ASCII characters not currently in use but being mentioned since
some of those might be used later or to say why they're not in use.
* Added new file "util/Input_Method_Muldis_D.cin" which is the first
cut of a generic-format "input method" plugin, that can be installed
as-is under various operating systems including Mac OS X 10.5, whose
use should make it much easier to type the various trans-ASCII symbols
that the Muldis D concrete syntaxes allow you to use for operators/etc.
Of course, you might already have some other "input method" tool to use
already that helps with mathematical/etc symbols so the one bundled
with the Muldis D spec may be redundant; but otherwise it should help.
To use it in Mac OS X, simply drop it in your "~/Library/Input Methods"
and log out plus log in and enable it in the "International" System
Preference panel. Also updated "util/README" about this file.
* (Routines.pod, Integer.pod, Rational.pod, QRelation.pod,
Temporal.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the
documentation in general to use more correct terminology with respect
to symmetric dyadic functions, so that it now calls each a "symmetric
function" rather than a "function with 2 mutually commutative main
parameters", or added said note in the first place. The descriptions
of these 10 functions were thusly updated:
"sys.std.Core.Universal.is[|_not]_identical",
"sys.std.[Integer|Rational].abs_difference",
"sys.std.QRelation.[is[|_not]_disjoint|composition]",
"sys.std.Temporal.[|UTC|Float]Instant.abs_difference". In all 3 STD
files, renamed the 2 pod sub-sections "Simple [C|Non-c]ommutative
Dyadic Infix Operators" to "Simple [S|Non-s]ymmetric Dyadic Infix
Operators" and otherwise updated them; also renamed all syntax nodes
containing "[|non]comm_dyadic" to replace that with "[|non]sym_dyadic".
* (Routines.pod, Ordered.pod, Blob.pod) Annotated any N-adic functions
that previously were directly described with "commutative and
associative" to now also say "idempotent" when the main inputs were
supplied as a q/set argument and not a q/bag. These 7 functions were
thusly annotated: "sys.std.Core.Bool.[and|or]",
"sys.std.Core.QRelation.[union|intersection|join]",
"sys.std.Ordered.min", "sys.std.Blob.and". Now more functions than
these are idempotent, but their descriptions say "like function foo".
* (Types_Catalog.pod, PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated
the "RatRoundRule" type definition to make it a (non-ordered) scalar
type (with a single empty-string-name possrep) rather than a tuple
type; the type is otherwise unchanged, having the same attributes and
interpretation etc. As a corresponding change in all STD dialects, the
attributes of a "RatRoundRule" node are now defined at compile time
rather than at runtime; they are now "Int" or "RatRoundMeth" node
payloads rather than being generic "expr" nodes, and so, a
"RatRoundRule" node is now a "opaque_value_literal" rather than a
"coll_value_selector"; if you want to define a "RatRoundRule" at
runtime, you must now use a "Scalar" node to do it instead. In the STD
dialects, renamed the "Rational Rounding Rule Selectors" pod
sub-section to "Rational Rounding Rule Literals" and moved it upwards.
* (Routines.pod, QSet.pod, QBag.pod, Counted.pod, QArray.pod, Text.pod,
Blob.pod) Renamed each of the 18
"is[|_not]_[member|element|subarray|substr[|_bits|_octets]]" functions
to "has[|_not]_[member|element|subarray|substr[|_bits|_octets]]" so
that if the function's name was used infix then it would read correctly
with the canonical order of its 2 primary parameters.
* (Routines.pod, QRelation.pod, QBag.pod, Counted.pod) Updated each of
the 12 "is[|_not][|_proper]_subset" functions so that the canonical
sequence of its 2 primary parameters is reversed, so that if the
function's name was used infix then it would read correctly; also
renamed said 2 main parameters so that "look_for" is now "topic" and
"look_in" is now "other".
* (Routines.pod, QRelation.pod, QBag.pod, Counted.pod) Added 12
functions where each is an alias for another function save that its 2
primary arguments are transposed. The 12
"sys.std.Core.QRelation.is[|_not]_superset" and
"sys.std.QRelation.is[|_not]_proper_superset" and
"sys.std.QBag.is[|_not][|_proper]_superset" and
"sys.std.Counted.counted_is[|_not][|_proper]_superset" complement 12
"subset".
* (Ordered.pod) Renamed the "is_not_before" function to
"is_after_or_same". Added the 2 new functions "is_after",
"is_before_or_same", which are aliases for "is_before",
"is_after_or_same" save that their 2 primary arguments are transposed.
* (Types.pod, QSet.pod, PTMD_STD.pod) The special value "nothing" is
now also known by the extra names "empty set" and "∅"; the latter can
appear literally in code and the former is just descriptive. The
Perl-Hosted dialects don't use ∅ as usually Perl undef denot the value.
* (Types.pod, PTMD_STD.pod, HDMD_Perl5_STD.pod) The 2 boolean values
"false" and "true" can now alternately be written out in code as
"⊥" or "⊤" respectively; alternate descriptive names for
those 2 values are "contradiction" and "tautology" respectively. The
HDMD_Perl5_STD dialect was not updated since Perl 6 has a native Bool
type, which is the only allowed way to denote a Bool literal.
* (Routines.pod, Routines_Catalog.pod, Ordered.pod, Integer.pod,
Blob.pod, Text.pod, Rational.pod, QRelation.pod, QArray.pod, QBag.pod)
Updated the descriptions of 59 functions to add or update notes about
alternate names that the function or its operation are known as, in
particular adding the various math/etc symbols they represent.
* (Routines.pod, QRelation.pod) Added 6 functions where each is an
alias for another function. The 2
"sys.std.Core.QTuple.is[|_not]_member" alias the 2
"sys.std.Core.QRelation.has[|_not]_member". The 3
"sys.std.Core.QRelation.[count|[|assign_]antijoin]" alias the 3
"sys.std.Core.QRelation.[cardinality|[|assign_]semidifference]". The 1
"sys.std.QRelation.symmetric_diff" aliases the 1
"sys.std.QRelation.exclusion".
* (PTMD_STD.pod) Updated "Comment" literals in a few ways. A
"Comment" GCVL may no longer omit its "value_kind"; this is to help
distinguish comment literals intended to be actual data (these have the
"value_kind") from those intended to be metadata for other code (these
are SCVLs and still lack the "value_kind"). Whitespace between comment
payload segments is now mandatory rather than optional. A payload
segment may now be just a run of 2+ hash-marks, in order that one can
simply use them for visual dividing lines in the code. Also added note
to be careful since hash-marks may hav other uses in PTMD_STD code now.
* Added new file "lib/Muldis/D/Ext/Bool.pod" which houses the new
"Muldis D Bool Extension". This extension defines extra operators for
boolean logic, adding to the minimum few defined in the language core.
This file has an initial complement of 9 new functions (7 standalone
plus 2 aliases), all in the "sys.std.Bool.\w+" namespace: "nand",
"nor", "xnor"/"iff", "imp"/"implies", "nimp", "if", "nif". (The 4 ones
in the core that these supplement are: "not", "and", "or", "xor".) The
"xnor"/"iff" op is N-adic/commutative while all the other new ops are
dyadic; of the latter, "nand" and "nor" are symmetric, and the others
aren't. And so, now all 2 niladic, 4 monadic, 16 dyadic boolean logic
operators are directly represented in Muldis D somehow.
* (D.pm, Core.pod, README) Added basic references to the new Bool.pod
file.
* (SeeAlso.pod) Added a couple "INFORMATION SOURCES" items, which are
about the boolean logic operators.
* (PTMD_STD.pod) In the "GENERIC VALUE EXPRESSIONS" main pod section,
changed the spelling of the "infix_bind_op" from "=" to "::=".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within mainly the "FUNCTION
INVOCATION ALTERNATE SYNTAX EXPRESSIONS" main pod section, renamed the
2 is/not-equal infix operators from "===", "!===" to "=", "≠"
respectively.
* (PTMD_STD.pod) Within the "Simple Commutative N-adic Infix Reduction
Operators" pod sub-section, changed the meaning of the relational op
spelled "R*" so that it now means "intersection" rather than "join".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the "FUNCTION
INVOCATION ALTERNATE SYNTAX EXPRESSIONS" main pod section, added one or
more aliases / alternate spellings of the N operators whose original
spellings were these: "≠", "and", "or", "xor", "not", "R+", "R*", "R-",
"R/". With the not-equal op and the 4 boolean ops, the original
spellings remained as the main spellings; with the 4 relational ops,
one of the new spellings became the main: "∪", "∩", "∖", "÷".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within 4 of the existing pod
sub-sections of the main pod section "FUNCTION INVOCATION ALTERNATE
SYNTAX EXPRESSIONS", added function-specific concrete syntaxes for 25
more (non-plain-alias) functions; each of those functions had between 1
and 4 special syntaxes specific to it, most just 1 or 2. This
consisted of 7 boolean functions and 18 relational functions. Also
added 1 example each for 3 of the newly treated functions; the other 22
don't have examp specif to them, but they are th same format as others.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the main pod section
"FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS", added new pod
sub-section "Order Comparison Operators", which provides
function-specific concrete syntaxes for 9 more (non-plain-alias)
functions; 5 of those functions had 1 special syntax specific to it, 2
had 2 each, and 2 had 7 each. In PTMD_STD, this section introduced the
new main node kind "ord_compare_op_invo".
* (Types_Catalog.pod) Other minor updates.
* (BBEdit_LM_Muldis_D.plist) Updates corresp to recent spec changes.
2009-05-19 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.73.0 is released on CPAN as
Muldis-D-0.73.0.tar.gz.
* (Types_Catalog.pod, Basics.pod, Types.pod, Text.pod, PTMD_STD.pod,
HDMD_Perl[6|5]_STD.pod) Updated the "UCPString" type definition (and
consequently "Text"/etc) so it excludes the special/abnormal/UTF-16
"surrogate" codepoints between F;D800 and F;DFFF inclusive, and so now
just includes the complementary ranges within zero and 0x10FFFF
inclusive. Also updated any references to "codepoint" in the language
spec to specify "abstract codepoint" instead, which is more specific.
* (Types_Catalog.pod) Renamed the infinite number of "String.*" types
so that their unqualified names are just spelled out with sequences
delimited base-10 integer literals rather than with essentially their
own native values. Then updated the "Name" type so it now has the same
character repertoire as "Text" or "Comment"; its sole possrep attribute
is now a "UCPString" rather than a "String".
* (Types_Catalog.pod) Updated the "Name" and "Comment" types so that
now each is a thin wrapper over the "Text" type rather than over the
"UCPString" type. The main consequence of this change is that now all
system-defined character string types can be used with the operators
defined for the "Text" type, and also that any future enhancements to
the "Text" type itself or its operators are also shared by the other
character string types.
* (Basics.pod, Types.pod, Text.pod, PTMD_STD.pod) Updated the Muldis D
concept of a character string, which used to be simply a sequence of
Unicode codepoints, so it is both more restricted and more abstract at
the same time. Updated the "Text" type so that its codepoint string
must now be in canonical decomposed normal form (NFD); a consequence of
this is that two character strings will now generally match at the
grapheme abstraction level, which is more user friendly than the old
behaviour, especially since the actual codepoints used to build a
grapheme is typically an implementation detail they don't control. Now
also the possrep of "Text" was renamed from "codepoints" to
"nfd_codepoints". In Text.pod, renamed the "length_in_codepoints"
function to "length_in_nfd_codepoints" and deleted the 2 functions
"folded_to_NF[C|D]" which are now meaningless.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the main pod section
"COLLECTION VALUE SELECTORS", added new pod sub-section "Rational
Rounding Rule Selectors", which declares syntax specific to selecting
"sys.std.Core.Type.Cat.RatRoundRule" values, which may be used a lot in
value expressions involving rational numbers. In PTMD_STD, this
section introduced these new 2 main ("value") node kinds:
"RatRoundRule[|_payload]".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the main pod section
"FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS", normalized the
basic format of "func_invo_alt_syntax"/"op" nodes. In PTMD_STD this
was just a documentation/concept update, while in both Perl-STD this
was an actual design change. In both Perl-STD, all kinds of op nodes
have exactly 3-4 ordered elements rather than 3-N; previously the 3rd+
elements were the op args, and now the 3rd element is an array of
main/mandatory op args and the 4th is a hash of extra/optional ones;
the dyadic op code examples were updated as approp; N-adic were unch.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Refactored the grammar by
splitting the 2 pod sub-sections ["Infix N-adic Reduction Operators",
"Infix Homogeneous Dyadic Operators"] into the 4 pod sub-sections
["Simple [C|Non-c]ommutative N-adic Infix Reduction Operators", "Simple
[C|Non-c]ommutative Dyadic Infix Operators"]. Correspondingly, in
PTMD_STD, the 2 main node kinds "infix_[reduce|h_dyadic]_op_invo" were
split into the 4 main node kinds
"[|non]comm_[infix_reduce|dyadic_infix]_op_invo".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added 2 more
function-specific concrete syntaxes to the existing pod sub-section
"Simple Commutative Dyadic Infix Operators".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Within the main pod section
"FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS", added 3 more pod
sub-sections ["Simple Monadic P[re|ost]fix Operators", "Rational
Operators That Do Rounding"]. The additions provide 11 more
function-specific concrete syntaxes. In PTMD_STD, these sections
introduced these new 3 main node kinds: "monadic_p[re|ost]fix_op_invo",
"rat_op_invo_with_round".
* (BBEdit_LM_Muldis_D.plist) Updates corresp to recent spec changes.
2009-05-15 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.72.0 is released on CPAN as
Muldis-D-0.72.0.tar.gz.
* (PTMD_STD.pod) Corrected the "[|d_]utc_duration_body" tokens so that
their 6th (rational) element was optional and had a leading comma.
* (Types_Catalog.pod, PTMD_STD.pod) Added a comment paragraph to each
of the "BagSelExprNodeSet" type definition and the "Bag" grammar node
definition, to clarify that any explicit "count" values a programmer
writes are compile-time constants, and if they want "count" values to
be determinable at runtime, they'll have to use a "RelSelExprNodeSet"
tuple or "Relation" node to specify the q/bag value selection instead.
* (PTMD_STD.pod) Reverse-refactored the grammar so that minor
separator or delimiter tokens were merged into the places that used
them, generally making the latter less verbose and easier to understand
at a glance; arguably the extra semantic information gotten from naming
these tokens was trivial and didn't need to be spelled out. The
eliminated distinct tokens were these 13: "term_sep",
"value_[node|payload]_elem_sep", "segment_sep", "name_chain_elem_sep",
"[list|pair]_elem_sep", "[[|non]ord|param]_list_[open|close]". Then
following those changes, cleaned up any superfluous "\w+".
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new main pod section
"FUNCTION INVOCATION ALTERNATE SYNTAX EXPRESSIONS" with the initial 2
pod sub-sections ["Infix N-adic Reduction Operators","Infix Homogeneous
Dyadic Operators"]. In PTMD_STD, these sections introduced these new 3
main node kinds: "func_invo_alt_syntax", "infix_reduce_op_invo",
"infix_h_dyadic_op_invo". The additions provide an initial complement
of 23 special concrete syntaxes for invoking some functions, for
example allowing one to invoke the typical mathematical operators using
infix notation rather than the normal prefix notation of "func_invo".
* (HDMD_Perl5_STD.pod, BBEdit_LM_Muldis_D.plist) Other minor updates.
2009-05-14 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.71.0 is released on CPAN as
Muldis-D-0.71.0.tar.gz.
* (Basics.pod) Corrected the "Referencing Data Types" pod subsection
of "ENTITY NAMES" so that the "type.type." namespace prefix only is
used to reference attributes of directly referenceable types, and it is
not used to simply reference a directly referenceable type. Also
clarified that the "type." top level namespace *is* used when
"tuple_from."/etc or "array_of."/etc are used and
"[var|type|func_result|param]." is not used.
* (PTMD_STD.pod) Updated the "NameChain" node payload definition to
add a third special case where the chain may be abbreviated, which is
that with "type." chain prefixes, the prefix-leading "type" element may
be omitted when the chain prefix contains a "tuple_from."/etc or
"array_of."/etc, since the latter's presence keeps things unambiguous.
* (Integer.pod) Updated the "sys.std.Integer.power" function so that
zero raised to the power of zero is no longer considered a failure but
rather results in 1, which seems reasonable given that this specific
function strictly has no numeric continuity (unlike "Rational.power")
and that this is by far the most common practice in both pure integer
math contexts and computer languages, including SQL.
* (Rational.pod) Updated the "sys.std.Rational.power" function to add
a "round_rule" parameter; this is a correction since it was previously
assumed that "power" with rational arguments would have a rational
result in the general case, which was wrong (take 2 ^ 0.5 for example).
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Updated the main pod section
"GENERIC VALUE EXPRESSIONS" with the new main node kind "named_expr",
which lets you give an explicit name to an "expr" node (that can then
be referenced with an "expr_name" node).
* (PTMD_STD.pod) Partially reformatted the grammar with a new syntax
that is a hybrid between the Perl 6 rules used before and EBNF with
further changes. There are exactly 2 main differences from before. The
first is that all explicit capturing syntax is gone (the parenthesis
that is). The second is that a token is now declared as "<footok> ::=
..." rather than "token footok { ... }"; the actual ... is unchanged
save for the previous sentence. Also rewrote the second half of the
"GENERAL STRUCTURE" main pod section (format explanation) accordingly,
also adding more information on how tokens and capture nodes relate.
2009-05-11 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.70.0 is released on CPAN as
Muldis-D-0.70.0.tar.gz.
* This release features large new additions to all 3 bundled dialects,
such that the entire generic concrete syntax for Muldis D value
expressions is now specified, and not just the syntax for literals.
* (Types_Catalog.pod) Fixed a fossil in the description of the
"namespaces" attribute of the "System" catalog type: "DeclNameChain"
value literals no longer have leading and trailing periods.
* (Routines.pod, Routines_Catalog.pod, Integer.pod, Blob.pod, Text.pod,
Rational.pod, QArray.pod, Temporal.pod) Updated all the simpler
system-defined (N-ary) reduction operators, specifically those
functions that can succeed in all cases with zero input values, so to
make their only parameter optional; when such a function is invoked
with no explicit argument, the result is the same as if it were given
an explicit empty list argument, and so the result of an invocation
with no argument is the function's identity value. The 15 functions so
updated are: "sys.std.Core.Bool.[and|or|xor]",
"sys.std.Core.QRelation.[join|product]",
"sys.std.Core.Cat.Order.reduction",
"sys.std.[Integer|Rational].[sum|product]",
"sys.std.[Blob|Text|QArray].catenation",
"sys.std.Temporal.[|UTC]Duration.sum".
* (Routines.pod) Added new function
"sys.std.Core.Universal.is_not_value_of_type" which is a simple
complement to the existing "is_value_of_type" function.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Added new main pod section
"GENERIC VALUE EXPRESSIONS" with the initial 4 pod sub-sections
["Generic Function Invocation Expressions", "Generic If-Else
Expressions", "Generic Given-When-Default Expressions", "Library Entity
Reference Selector"]. In PTMD_STD, these sections introduced these new
6 main node kinds: "expr", "expr_name", "func_invo_expr",
"if_else_expr", "given_when_def_expr", "lib_entity_ref_selector". The
additions round out the entire generic concrete syntax for Muldis D
value expressions, when added to all the kinds of "value" nodes that
the grammars had before.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Other minor updates.
2009-05-08 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.69.0 is released on CPAN as
Muldis-D-0.69.0.tar.gz.
* (Types_Catalog.pod) Fixed a fossil in the description of the
"namespaces" attribute of the "System" catalog type where mention of
the 2 namespaces "tpc" and "tpc.cat" had been omitted.
* (PTMD_STD.pod) Corrected the "bootloader" grammar token, which
didn't have whitespace between its elements; added new token
"term_sep", which indicates mandatory whitespace.
* (PTMD_STD.pod) Updated the "Value Literal Common Elements" pod
subsection to add a description on how a "type_name" element of a
"value" node is interpreted depending on context.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Took what used to be the
"auto_unabbrev_std_names" pragma and made it into standard behaviour,
also eliminating that pragma in the process. Updated the "NameChain"
node payload definition so it now may have as few as 1 element rather
than as few as 2. As per the old pragma, now any name chains for
invoking system-defined types and routines can be written typically as
its unqualified short name, eg "Int" for "sys.std.Core.Type.Int", and
it would be unambiguously expanded by the parser. The Muldis D spec
itself had been using such abbreviations for a long time, but now that
practice has been formally specified. As a new further expansion of
this feature, now any name chains for invoking named value expressions
or variables etc can have any leading "lex." element omitted, and it
would be unambiguously re-added by the parser.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Eliminated a fossil which is
the "auto_chains_from_names" pragma; this hasn't actually been useful
for awhile now.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) Eliminated the last pragma,
"auto_add_attrs", since its usefulness is now questionable; however,
that functionality might return in the future, maybe with alterations,
or perhaps better as a feature in the system catalog itself.
* (PTMD_STD.pod, HDMD_Perl[6|5]_STD.pod) A bit of grammar refactoring:
Split "Tuple and Database Selectors" 2 ways into "Tuple Selectors" and
"Database Selectors". Split the 2 "QTuple[|_payload]" nodes into
themselves and the 2 new "Database[|_payload]".
* (Basics.pod, [Types|Routines]_[|Catalog].pod, QBag.pod, SeeAlso.pod,
INSTALL) Corrected several instances of repeated word typos.
* (PTMD_STD.pod) Other minor fixes.
2009-05-06 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.68.0 is released on CPAN as
Muldis-D-0.68.0.tar.gz.
* This release features the renaming of all the bundled Muldis D
dialects/grammars from "_Tiny" to "_STD", which seems more appropriate
now. Renamed the 3 files "[PTMD|HDMD_Perl[6|5]]_Tiny.pod" to
"[PTMD|HDMD_Perl[6|5]]_STD.pod". Updated any references in these other
files to reflect the new dialect names: README, D.pm, Basics.pod,
Types.pod, BBEdit_LM_Muldis_D.plist.
* (Basics.pod, HDMD_Perl5_STD.pod) Other minor fixes.
2009-05-04 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.67.0 is released on CPAN as
Muldis-D-0.67.0.tar.gz.
* (PTMD_Tiny.pod) Simplified the grammar so it doesn't do work that
could just as easily be, or would better be, done after the early
parsing stage that the grammar describes. Simplified the 2
"[UTC|Float]Instant_payload" tokens so they simply alias the
"UTCDuration_payload"; all 3 now simply look for a sequence of 5
integers followed by a rational, rather than restricting to integers
that are specifically non-negative or positive. Then deleted the 6
now-unused tokens "[[|d_][nn[int|rat]|utc_instant]_body".
* (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod) Updated the grammar for
language name literals to make the 5th/extensions part optional; you no
longer have to have an explicit empty list when you're using defaults.
* (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod) Updated the grammar for
"RatRoundMeth" value literals so that it may now have a "type_name"
element like most value literals (all but "Bool" and "Order").
* (Types.pod) In Types.pod, deleted the singleton data type "Nothing"
as it no longer seems useful to have singleton data types that are not
root types. Then updated the description of the "Maybe" data type to
say that its sole value with zero elements is now also known by the
special name "Maybe:nothing", aka "nothing".
* (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod) Updated all Muldis D
dialects so to merge the 2 value node kinds of "Single" and "Nothing"
into the single new kind "Maybe", which provides the new terse means to
select "Maybe" values. The syntax for "Maybe" is the same as "Single"
was, save for the keyword "Maybe" replacing "Single", and also that new
syntax is added for selecting the value "nothing". In PTMD_Tiny, the
syntax "Maybe:{...}" means a "Single" value and "Maybe:nothing" means
the "nothing" value; also the latter may now be spelled with an omitted
"value_kind" like "Int" nodes et al, as just "nothing". In
HDMD_Perl[6|5]_Tiny, a Perl defined payload indicates a "Single" value,
while the Perl undef value indicates the "nothing" value; this change
should make dynamic generation of "Maybe" literals easier considering
that Perl users tend to equate the Perl concept of undefined with the
SQL concept of NULL, meaning nothing more than "not a normal value".
* (Basics.pod, Types_Catalog.pod, Routines_Catalog.pod, QRelation.pod,
QSet.pod, Temporal.pod) Updated any other files having references to
"Nothing" so they reference "nothing" instead.
* (Types.pod, Basics.pod, Types_Catalog.pod, QRelation.pod, QTuple.pod)
In Types.pod, deleted the data types "TupleD0" (singleton) and
"RelationD0" (2 values) as they no longer seem useful; then updated the
descriptions of the "Tuple" and "Relation" data types to give
additional special names to the corresponding 3 values, "Tuple:d0" and
"Relation:d0c[0|1]". Updated any other files having references to the
"D0" types so they reference the "d0" value names instead.
* (HDMD_Perl[6|5]_Tiny.pod) Split up the "GENERAL STRUCTURE" main pod
section into itself and the new "VALUE LITERALS AND SELECTORS"; then
the latter was moved to be just above "OPAQUE VALUE LITERALS". Also
added the initially empty/todo new main pod section "DEPOT
DECLARATION", just above "BOOTLOADER STATEMENT".
* (HDMD_Perl[6|5]_Tiny.pod) Updated all the main pod sections
["GENERAL STRUCTURE", "BOOTLOADER", "LANGUAGE NAME", "VALUE LITERALS
AND SELECTORS", "OPAQUE VALUE LITERALS", "COLLECTION VALUE SELECTORS"]
and all their pod sub-sections, to strip out or summarize any Perl-Tiny
description text that is redundant with the description text of the
PTMD_Tiny dialect, since the former should now be able to piggyback on
the latter; otherwise updated or rewrote or cleaned them up.
* (HDMD_Perl[6|5]_Tiny.pod) Removed the now-unneeded brief main pod
section REWRITE PROGRESS MARKER, in both files.
* (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod) Other minor updates, fixes.
* (BBEdit_LM_Muldis_D.plist) Updated this file to the latest grammar.
2009-04-29 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.66.0 is released on CPAN as
Muldis-D-0.66.0.tar.gz.
* This release features major updates and additions to the PTMD_Tiny
dialect, including fleshing out of descriptive text, such that this
dialect's definition is now fully self-defined and you no longer have
to look at the HDMD_Perl[6|5]_Tiny dialects to fill in the gaps.
That's not to say that the concrete grammars are complete (they're
not), but now PTMD_Tiny is no longer lagging the other dialects with
regard to completeness.
* (Types.pod, Types_Catalog.pod, Basics.pod) Renamed all of the
"String" types from the generic "sys.std.Core.Type.\w+" namespace to
the catalog-focused "sys.std.Core.Type.Cat.\w+" namespace, and moved
their definitions from Types.pod to Types_Catalog.pod; specifically the
5 normal types "(|SE|B|O|UCP)String" plus the infinite number of
"String.*" types were renamed. The main reason for this change was to
emphasize that the "String" types are not generally intended for direct
use with user data, and should only be used mainly by other
system-defined types and operators in their definitions.
* (Routines_Catalog.pod, QTuple.pod) Renamed the 3 functions
"sys.std.Core.Cat.Order_[[|conditional_]reverse|reduction]" to
"sys.std.Core.Cat.Order.[[|conditional_]reverse|reduction]".
* (PTMD_Tiny.pod) Split the pod section "VALUE LITERAL COMMON
ELEMENTS" into the 2 sections "VALUE LITERALS AND SELECTORS" and "Value
Literal Common Elements". Renamed the illustrative grammar token
"value" to "x_value", leaving just the one "value" that should actually
be used in a generic grammar.
* (PTMD_Tiny.pod) Updated every kind of quoted character string
literals so that non-"space" whitespace characters may no longer appear
literally, but must instead be denoted with escape sequences; to be
specific, disallowed the 4 characters "\t\n\f\r" from appearing
literally. The main reason for this change was to ensure that the
actual values being selected by char str literals were not variable per
the kind of linebreaks used to format the Muldis D source code itself.
These 3 grammar tokens were updated: "[text|comment|_payload]",
"quoted_name_str".
* (PTMD_Tiny.pod) Added another simple escape sequence for quoted char
str literals, "\s", representing a space (F;20). Updated "Comment"
literals so they can have optional leading or trailing space chars
inside the # delimiters which are not part of the selected Comment
value; you must escape leading/trailing spaces now if you want them
included in the value. These 2 grammar tokens were updated:
"comment_payload", "escaped_char".
* (PTMD_Tiny.pod) Renamed a few generic grammar tokens:
"int_max_col_val" -> "num_max_col_val", "list_[open|close]" ->
"nonord_list_[open|close]".
* (PTMD_Tiny.pod) Refactored grammar tokens concerning generic
relations, UTC temporals, etc. Merged the "qrelation" token into the
"value" token (and "payload"), then renamed the 2
"generic_qrelation[|_payload]" to "qrelation[|_payload]", and renamed
the 3 "generic_relation_\w+_payload" to "r_\w+_payload". Split the 2
tokens "utc_instant[|_payload]" into themselves and
"float_instant[|_payload]", and updated the "value" and "payload"
tokens accordingly. Split the token "value" 3 ways into itself and
"opaque_value_literal" plus "coll_value_selector".
* (PTMD_Tiny.pod) Updated the whole PTMD_Tiny grammar to add capturing
parenthesis, so to help illustrate a map between the concrete grammar
and anticipated parse tree nodes, which HDMD_Perl[6|5]_Tiny are to a
large degree.
* (PTMD_Tiny.pod) Renamed all the grammar tokens that are either the
main tokens or main payload tokens for value literals or selectors, so
to spell the tokens the same way as their "value_kind" components which
is the resulting type names; for example, the tokens that were named
"rat_round_meth[|_payload]" are now named "RatRoundMeth[|_payload]".
This also means that the grammar tokens and capture node names
("value_kind") now actually match each other.
* (PTMD_Tiny.pod) Split up the following grammar tokens into
themselves and additional parts, so to make them more self-documenting:
"Blob_payload", "[[UTC|Float]Instant|UTCDuration]_payload",
"String_payload", "r_ordered_qattr_payload".
* (PTMD_Tiny.pod) Updated the grammar tokens [Int, Rat, Blob,
UTCInstant, FloatInstant, String, QTuple] and "value_kind" to add one
or more "value_kind" alternative values which provide a terser
alternative to common settings of a "value" node's "type_name"; for
example, added "NNInt", "OctetBlob", "UTCDate", and "Database".
* (PTMD_Tiny.pod) Updated the top-level grammar so the language root
token is "bootloader" and it composes a "language_name" token plus
exactly one alternative between the 3 tokens "value", "depot", (a
sequence of) "boot_stmt". The "depot" one is new, and is declared in
the new pod section "DEPOT DECLARATION". Fleshed out the pod sections
"BOOTLOADER", "VALUE LITERALS AND SELECTORS", "COLLECTION VALUE
SELECTORS" with their own description paragraphs, and removed now
redundant text from "GENERAL STRUCTURE". Also small "DESCRIPTION"
updates. Also split the token "boot_stmt" into itself plus
"generic_boot_stmt", the latter being the first of unspecified
alternatives in the former, todo in a subsequent release. The new
"depot" token references 2 undeclared/todo tokens
"depot_[catalog|data]". Also updated the appropriate sub-tokens of
"Q[Tuple|Relation|Set|Single|Array|Bag" so they now embed "expr" tokens
rather than "value"; declaring the "expr" token is todo.
* (PTMD_Tiny.pod) Updated the "LANGUAGE NAME" main pod section plus
all the pod sections specific to value node literals/selectors to add
complete desc paragraphs to each one, all of these derived from their
counterpart desc text in the HDMD_Perl[6|5]_Tiny.pod files.
* (PTMD_Tiny.pod) Removed the now-unneeded brief main pod section
REWRITE PROGRESS MARKER.
2009-04-28 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.65.1 is released on CPAN as
Muldis-D-0.65.1.tar.gz.
* (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod) Rearranged some POD
sections: Moved "BOOTLOADER" to just above "LANGUAGE NAME". Moved
"Nothing" to just above "Bool". Moved "Order" and "RatRoundMeth" to
just below "Bool". Moved "Rat" to just below "Int". Moved
"[Instant|Duration]" to just below "Comment". Moved
"[UTCInstant|FloatInstant|UTCDuration]" to just below "Duration".
Moved "String" to just below "UTCDuration". Renamed "SIMPLE CORE
SCALAR VALUE LITERALS" to "OPAQUE VALUE LITERALS", and "GENERIC
Q/SCALAR AND Q/NONSCALAR VALUE LITERALS" to "COLLECTION VALUE
SELECTORS", and removed the now-empty "TEMPORAL EXTENSION SCALAR VALUE
LITERALS" heading. Following these changes, "OPAQUE ..." has "Nothing"
plus all the q/scalar selectors, including all the temporal selectors,
but not "[|Q]Scalar", and "COLLECTION ..." has "[|Q]Scalar" plus all
the q/nonscalar selectors, but not "Nothing". The distinction between
these 2 new groups is that "COLLECTION ..." has all the selectors which
are visibly collections of other nodes, while "OPAQUE ..." has all the
selectors which visibly have no component nodes; the latter are always
constant expressions while the former might vary at runtime if child
nodes are say function invocations or routine parameters.
* (PTMD_Tiny.pod, HDMD_Perl[6|5]_Tiny.pod) Renamed all the level-2 /
type-specific pod section headings from "sys.std.Core[.Cat]?.\w+" to
headings that are more generic, in the process also merging a few
similar such pod sections; 24 sections per file became 20. The 3
sections "[Name|NameChain|DeclNameChain]" merged into the 1 "DBMS
Entity Name Literals", the 2 sections "[Instant|Duration]" merged into
the 1 "TAI Temporal Literals", the 2 sections
"[[UTC|Float]Instant|Duration]" merged into the 1 "UTC and Float
Temporal Literals". The simple renames were these 17 sections:
"Nothing" -> "The Nothing Literal", "Bool" -> "Boolean Literals",
"Order" -> "Order-Determination Literals", "RatRoundMeth" -> "Rational
Rounding Method Literals", "[Int|Rat]" -> "General Purpose
[Integer|Rational] Numeric Literals", "[Blob|Text]" -> "General Purpose
[Binary|Character] String Literals", "Comment" -> "Code Comment
Literals", "String" -> "Low Level Integer String Literals", "Tuple" ->
"Tuple and Database Selectors",
"[Q|][Scalar|Relation|Set|Single|Array|Bag]" ->
"[Scalar|Relation|Set|Single|Array|Bag] Selectors",
* (HDMD_Perl[6|5]_Tiny.pod) Various other minor updates and fixes.
2009-04-22 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.65.0 is released on CPAN as
Muldis-D-0.65.0.tar.gz.
* (PTMD_Tiny.pod) Updated the possible simple escape sequences
allowable in quoted character string literals. The escape for
backslash (F;5C), "\b", is unchanged. The escape for
apostrophe/single-quote (F;27) is now "\a" rather than "\q". Added 2
more escapes for visible characters, "\q" for double-quote (F;22) and
"\h" for number-sign/hash (F;23). Also added 4 more escapes for the
most commonly written out invisible/control characters, that match
their common meanings: "\t" for tab (F;9), "\n" for line-feed/newline
(F;A), "\f" for form feed (F;C), "\r" for carriage return (F;D). Note
that, unlike with Perl/etc where the meaning of "\n"/etc may change
depending on context, in Muldis D each escape always represents the
same single Unicode codepoint. The multi-part escape sequences
"\c<...>" were unchanged. As part of this update, the grammar token
"quoted_char_str" was split into itself and "escaped_char".
* (PTMD_Tiny.pod) Differentiated further the 3 main kinds of character
string literals (Text/Blob, Name/chains, Comment) by giving each
different delimiter characters. Text and Blob retain their existing
apostrophe/single-quote delimiters. Name and chains based on it now
have double-quote delimiters when they are quoted at all, and they can
still be barewords where they could before; in practice there is little
change here since most Name/chains tend to be barewords. Comment now
has numer-sign/hash delimiters, so it looks much like a Perl/etc
comment except that a trailing # is also necessary; furthermore,
segmented Comment literals now no longer use a tilde/~ between segments
(Text/Name/etc still do), rather they just have optional whitespace
between segments. Regarding char escape sequences, within each kind of
quoted character string literals, it is only mandatory to escape the
same character as delimits that particular literal plus the backspace;
using the other escapes is optional. As part of this update, the
grammar token "quoted_char_str" was removed and a customized version
inlined into each payload/etc token that used to include it, and the
tokens related to Name literal payloads were reorganized. Also updated
all relevant code examples to reflect the delimiter changes for
Name/etc and Comment.
* (D.pm, PTMD_Tiny.pod) The previous change item also affected the
format of PTMD_Tiny fully-qualified Muldis D language names; the
authority and version number parts are now delimited with double-quotes
as per Name, rather than single-quotes.
* (PTMD_Tiny.pod) Updated the support for unqualified value literals
so "Comment" literals may now be written that way. The only updated
grammar token is "comment".
* (BBEdit_LM_Muldis_D.plist) Partially rewrote this file, mainly the
syntax coloring regexes, to be cleaner and to reflect the previous
PTMD_Tiny change items. Also, Name/NameChain/DeclNameChain literals
are no longer colored at all, since in general they should be treated
consistently as identifiers. Also, the "value kind" barewords,
essentially all the unqualified main type names, are no longer colored
as language keywords, as they should be treated consistently with
either type or routine invocation names.
* (BBEdit_LM_Muldis_D.plist) Made several additions corresponding to
anticipated PTMD_Tiny grammar that is yet to be codified in the spec.
Rewrote the routine scanning pattern to look for
"[inner_]?[function|updater|procedure]" rather than "[name|'name'] \s*
=> \s* Name:". Added a couple dozen new keywords to the syntax
colorer, including both the routine makers and a bunch of possible
infix operators that are actually sugar over normal prefix operators.
* (Basics.pod, Types_Catalog.pod, Routines.pod, Ordered.pod,
QTuple.pod, QSet.pod) In Basics.pod, in the "Ordered Types"
sub-section of "TYPE SYSTEM", updated the definition of an
"order_determination" routine to give it a 4th, boolean parameter,
"is_reverse_order", which is mandatory to define but optional to
invoke. It is now normal/expected that every order-determination
function will fundamentally know how to operate both normally and in
reverse, and support an ascending or descending value sort, with that
ability being orthogonal to any other customizability it might have.
In Types_Catalog.pod, updated the description of the "order" attribute
of the "InnerScalarType" type to conform to the updated ord-det routine
definition. In Routines.pod, updated the "sys.std.Core.QScalar.order"
function to add a "is_reverse_order" parameter. In Ordered.pod,
deleted function "sys.std.Ordered.reverse_order", which is no longer
useful, and updated the description of the 2 functions
"sys.std.Ordered.is_[|not_]before". In QTuple.pod, updated the
"sys.std.QTuple.order_by_attr_names" function to add a
"is_reverse_order" parameter and otherwise update its description. In
QSet.pod, updated the description of the "sys.std.QSet.QMaybe.order"
function.
* (Routines_Catalog.pod) In Routines_Catalog.pod, added new function
"sys.std.Core.Cat.Order_conditional_reverse", which should make the
task of writing (bi-directional) generic "order_determination" routines
easier, for those who want to write the least code to do the job.
* (QRelation.pod, QArray.pod) Updated each of the following 9
functions to add a "is_reverse_order" parameter:
"sys.std.QRelation.[rank|limit][|_by_attr_names]",
"sys.std.QArray.[|limit_of_]QArray_from_wrap[|_by_attr_names]",
"sys.std.QArray.QArray_from_attr".
* (Integer.pod, Rational.pod, Temporal.pod) Updated all 6 "sum" or
"product" N-ary functions to rename each of their sole parameters to
"topic" from "addends" or "factors" that they were before. While
strictly speaking the old names were more descriptive, the new names
allow for better standardization in that all the other N-ary functions
of Muldis D already named their sole/primary parameter "topic".
* (Routines.pod) Other minor fixes.
2009-04-16 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.64.0 is released on CPAN as
Muldis-D-0.64.0.tar.gz.
* (Basics.pod) Minor updates to "NOTES ON TERMINOLOGY", clarifying
that a value literal is a common special case of a selector, and also
that a constant may alternately be a niladic function.
* (Types_Catalog.pod, Routines_Catalog.pod) Renamed the 8 relation
types "ScaLitExprNodeSet" and
"[ScaPR|Tup|Rel|[Func|Proc|Type|OrdDetFunc]Ref]LitExprNodeSet" to
"ScaValExprNodeSet" and
"[ScaPR|Tup|Rel|[Func|Proc|Type|OrdDetFunc]Ref]SelExprNodeSet"; the old
names were actually inappropriate because partly the concept of a
literal doesn't exist in a type definition (just in concrete code), and
also child nodes of these nodes are often non-literal expressions such
as function invocations. Also renamed the corresponding 8 attributes
of the database type "ExprNodeType", and updated the few other
references to the renamed types to use the new names.
* (Types_Catalog.pod) Added 3 new relation types
"sys.std.Core.Type.Cat.[Set|Ary|Bag]SelExprNodeSet" which are like
specialized versions of "RelSelExprNodeSet", with a simpler structure
for the commonly used Set|Array|Bag value selectors. Also added 3 new
corresponding attributes to the "ExprNodeType" type.
* (Types_Catalog.pod) Corrected an omission in the tuple type
"sys.std.Core.Type.Cat.InnerScalarType" by adding a new attribute
"subtype_constraint", used when we are defining a proper subtype of
another type, which constrains the base type's value set at least
enough such that the new type's possrep maps can work without error,
and it is possible for the new type's possreps' constraints to operate
without error. Also updated a few other cat type/attr descriptions.
* (Types_Catalog.pod, QTuple.pod, QRelation.pod, QArray.pod) Added new
order-determination function "sys.std.QTuple.order_by_attr_names" which
provides a convenient short-hand for ordering tuples of a relation
simply in terms of a list of attribute names; this saves users having
to declare their own order-determination function for this common
format of queries; also added new type
"sys.std.Core.Type.Cat.OrderByName" used by said new function. Also
added the 4 new wrapper functions
"sys.std.QRelation.[rank|limit]_by_attr_names" and
"sys.std.QArray.[|limit_of_]QArray_from_wrap_by_attr_names" which
combine the previous function with their partial namesakes. And so
Muldis D now provides a direct analogy to the SQL syntax "ORDER BY foo,
bar" etc that doesn't need a user-defined closure, though you still
need the latter for the general case of "ORDER BY <expr>".
* (Routines.pod) Changed the "sys.std.Core.QRelation.summary" function
by renaming its "result_attr_names" parameter to "summ_attr_names" and
redefining its functionality more in terms of "extension" rather than
"map"; the function given to "summ_func" must now just result in a
tuple with attributes to add to a result which now already has all the
attributes named by "group_per", rather than resulting in all
attributes for the result. The new version of "summary" should be much
easier to use as presumably users always want to keep the attributes
they are grouping per, and they now don't have to spell them out every
time. For the rare case where you want the old behaviour, now you have
to do it manually with an explicit "cmpl_group" plus "map".
* (Routines.pod, QBag.pod) Added new function
"sys.std.Core.QRelation.cardinality_per_group" which is like "summary"
but shorthands the common case where people just want a count of tuples
per group and not any other information. Also added new function
"sys.std.QBag.QBag_from_cmpl_group" which is like the other new
function but the result is a QBag.
* (QBag.pod) Added new function "sys.std.QBag.union_sum" which is like
"sys.std.QBag.union" but that counts in the result come from summing
the counts of the inputs rather than taking maximums of said. Also
updated the description of "sys.std.QBag.insertion" to clarify it is
semantically like "union_sum" and not "sys.std.QBag.union" which is the
direct analogy to set union.
* Added new file "lib/Muldis/D/Ext/Counted.pod" which houses the new
"Muldis D Counted Extension". This extension defines special
count-sensitive versions of all the common and applicable relational
operators in Routines.pod and QRelation.pod, each new one taking an
extra $count_attr_name argument that specifies which attribute of each
normal argument contains the count and is to be treated specially, such
that generally just the other attributes are considered in regards to
the normal semantics of the operators, and the count attributes are
summed or diffed as is appropriate. Having these operators
system-defined is probably the best way to support people who actually
want bag-of-tuple semantics, or most precisely simulate the general
case of bag-of-tuple behaviour of SQL for those using Muldis D as an
intermediate representation, and then various users won't be
reimplementing that wheel as multiple incompatible extensions. This
file has an initial complement of 22 new functions, all in the
"sys.std.Counted.\w+" namespace: "[add|remove]_count_attr",
"counted_[cardinality|is_[|not_]member|insertion|deletion]",
"counted_[[|cmpl_]projection|[|maybe_]reduction|map]",
"counted_is_[|not_][|proper_]subset",
"counted_[union[|_sum]|intersection|difference]"
"counted_[|static_]substitution".
* (D.pm, Core.pod, README) Added basic references to the new
Counted.pod file.
* (HDMD_Perl5_Tiny.pod) Fixed a few detail fossils that became
obsolete with last release's PTMD_Tiny changes. Updated details for
PHMD payloads of these 4 types: Bool, Int, Rat, Order.
* (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod) Removed a fossil each that
referenced the concept of a scalar without a possrep.
* (Basics.pod, Routines.pod, Types_Catalog.pod, Ordered.pod,
QRelation.pod) Minor updates.
2009-04-02 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.63.0 is released on CPAN as
Muldis-D-0.63.0.tar.gz.
* Added new file "util/BBEdit_LM_Muldis_D.plist" which is the first cut
of a Codeless Language Module for the BBEdit text editor for Mac OS X
that empowers BBEdit to syntax color and function scan code written in
the PTMD_Tiny dialect of Muldis D. Also added the support file
"util/README" which explains the CLM further. The new CLM is only as
complete as the language spec itself, and mainly what it is the most
complete about is syntax coloring Muldis D value literals. Also
updated the README file to refer to the "util/" and "archives/" dirs.
While not exactly its intended use, you can get a taste of the CLM
working by opening the PTMD_Tiny.pod file in BBEdit with the CLM
installed and look at the various code examples in the POD file.
* (Types_Catalog.pod) Updated the "RatRoundRule" type to replace its
"max_denom" attr (a "PInt") with a "min_exp" attr (an "Int"). This
change was made so that rounding could be specified more easily and
tersely; as well this change adds a feature in that rounding can now be
specified to a multiple of a whole number greater than one, and not
just to a multiple of a number of lesser or equal magnitude to one.
* (PTMD_Tiny.pod) Made "Name" (and chains etc) value literals stricter
in a couple ways. First, segmented Name payloads must now have all of
their segments quoted, not just those segments with characters outside
of the nonquoted repertoire; a corollary to this is that if you have an
otherwise nonquoted Name payload that is long enough to segment, you
have to make it quoted to do that. Second, nonquoted Name payloads
must begin with a letter or underscore and may no longer start with a
digit or hyphen; you must use the quoted form if you want to do that.
These changes were made to aid code readability and reduce confusion of
some Name literals with some Int literals. In the process, a bit of
grammar refactoring was done: "quoted_char_str_seg" was enlarged to
include "segment_sep" and was renamed to "quoted_char_str", and now
"[text|name|comment]_payload" refer to that; "nonquoted_char_str_seg"
was renamed to "nonquoted_char_str".
* (PTMD_Tiny.pod) Made "Bool" and "Order" value literals stricter such
that they may only be specified with values allowed for their "name"
possreps and no longer their "int" possreps. So for example, you can
say "Bool:false" or "false" but no longer "Bool:0". Updated grammar
tokens are "bool[|_payload]" and "order_payload".
* (PTMD_Tiny.pod) Updated the support for unqualified value literals
so "Order" and "RatRoundMeth" literals may now be written that way.
Updated grammar tokens are "order" and "rat_round_meth".
* (PTMD_Tiny.pod) Made the grammar token "pint_tail" stricter so that
two underscore separator characters may not appear in a row within any
of the value literals defined in terms of numeric values.
* (PTMD_Tiny.pod) Fixed a bug concerning all value literals defined in
terms of numeric values where the int-max-col-val prefix is omitted;
then the grammar should have allowed only the digits [0..9] are allowed
in the numeric, rather than the [0..9A..F] allowed when the
int-max-col-val is given. This affects the 8 types: Int, String, Rat,
Instant, Duration, [UTC|Float]Instant, UTCDuration, Bag. In the
process, added 7 grammar tokens each like the following 7 but for "d_"
(decimal) prefixed to their name: "[|nn|p]int_body",
"pint_[head|tail]", "[|nn]rat_body"; and updated the 8 grammar tokens:
"[int|string|rat][[|utc_][instant|duration]]_payload", "count".
* (PTMD_Tiny.pod) Fixed a bug concerning the "DeclNameChain" value
literal format where the SCVL of that type with zero elements is simply
the empty string, or the GCVL of the same has a trailing colon. To fix
this, updated the "decl_name_chain_payload" grammar token so that a
zero-element DeclNameChain is represented by the special payload "[]";
however, any DNC (or NC) with at least one element still have no "[]"
delimiters surrounding the chain literal (unlike for "String" etc).
* (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod) For each dialect, added an
example for each of the types "DeclNameChain" and "RatRoundMeth".
* (D.pm, SeeAlso.pod) Minor updates; changed notes about projects'
owners from Darren Duncan to Muldis Data Systems.
2009-03-20 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.62.3 is released on CPAN as
Muldis-D-0.62.3.tar.gz.
* (Routines_Catalog.pod) Fixed a few search+replace errors that
release 0.62.2 introduced.
* (Basics.pod, Types.pod, Routines.pod, Types_Catalog.pod,
Routines_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod,
Ordered.pod, Integer.pod, Blob.pod, Text.pod, Rational.pod,
Temporal.pod) General documentation reformat considering a frequently
employed writing short-hand. Often when text alternatives were
displayed, and they had portions in common, the short-hand used fake
Perl regex syntax; the main change was to update the short-hand to
resemble Perl 6 syntax more and Perl 5 syntax less, mostly by
substituting "[]" (non-capturing group) for "()". This change was made
partly so the new version is more readable considering "()" are used
for other purposes in the same contexts while "[]" weren't. It also
brings greater consistency since Perl 6 rules are the standard format
in other parts of the documentation for illustrating patterns.
2009-03-19 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.62.2 is released on CPAN as
Muldis-D-0.62.2.tar.gz.
* (Routines.pod, Routines_Catalog.pod, Ordered.pod, Integer.pod,
Blob.pod, Text.pod, Rational.pod, QTuple.pod, QRelation.pod, QSet.pod,
QArray.pod, QBag.pod, Temporal.pod) Second draft at reformatting all
system-defined routine signatures to match the planned new PTMD_Tiny
format for declaring routines. Where parameter declarations used to be
formatted "p1(T1)" or "&p1(T1)" or "&p1(T1)?", they are now formatted
"T1 $p1" or "T1 &$p1" or "T1 $p1?". This change does not alter the
verbosity one bit, but the code is arguably a lot prettier and easier
to read or write. So now PTMD_Tiny routine declarations now look
almost identical in format to Perl 6 declarations, in fact at a glance
one might confuse it for Perl 6. Note for those of you accustomed to
Perl 6 of these small differences: 1. all Muldis D params are named but
don't have the ':' prefix like Perl 6; 2. the $ is not actually part of
the parameter name, just syntactic sugar to help the grammar (there are
no @%... sigils); 3. pass-by-ref params are marked with & not "is ref".
2009-03-19 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.62.1 is released on CPAN as
Muldis-D-0.62.1.tar.gz.
* (Routines.pod, Routines_Catalog.pod, Ordered.pod, Integer.pod,
Blob.pod, Text.pod, Rational.pod, QTuple.pod, QRelation.pod, QSet.pod,
QArray.pod, QBag.pod, Temporal.pod) First draft at reformatting all
system-defined routine signatures to match the planned new PTMD_Tiny
format for declaring routines. Where function declarations used to be
formatted "function f result T0 params { p1(T1), p2(T2) }", they are
now formatted "function f (T0 <-- p1(T1), p2(T2))", and where
procedures/etc used to be formatted "procedure p update { p1(T1) } read
{ p2(T2) }", they are now formatted "procedure p (&p1(T1), p2(T2))". A
main benefit of this change is routine signatures should be
considerably less verbose and easier to read and more like those of
other languages, and also now subject-to-update parameters may now be
mixed with read-only parameters, since the & prefix now is what
indicates their being subject-to-update; similarly, routine invocations
would use the & for subject-to-update arguments as well.
2009-03-17 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.62.0 is released on CPAN as
Muldis-D-0.62.0.tar.gz.
* Congratulations to the developers of Parrot (Speaks Your Language),
which saw its long-awaited 1.0.0 release earlier today.
* (PTMD_Tiny.pod) Updated the "quoted_char_str_seg" grammar token to
add support for specifying characters in terms of their Unicode
codepoint name or number, in addition to the previous means of
specifying characters as their literal selves in the presumably Unicode
PTMD_Tiny source code. The new feature is in the form of the escape
pattern "\c<...>", where that any occurrences of such a substring in a
quoted character string literal are replaced with the actual Unicode
codepoint whose name or number is given by the "..."; the "..." takes a
form like either "A..Z " for character names (example "\c<LATIN SMALL
LETTER OU>") or "\d;\d+"|"\d+" for character numbers (examples
"\c<F;263A>" or "\c<65>". One reason for this feature is to empower
specifying exactly which sequence of codepoints you want for a
particular grapheme (which text editors tend to abstract away when you
write characters literally), and also it is to empower more elegant
passing of Unicode-savvy PTMD_Tiny source code through a communications
channel that is more limited, such as to 7-bit ASCII.
* (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod) Added "Text" value literal
example to all 3 Tiny grammars illustrating how to specify characters
in terms of Unicode codepoint names or numbers.
* (PTMD_Tiny.pod) Updated the "[|nn]rat_body" grammar tokens to be
stricter such that rational-type numbers now may never look like
integer-type numbers; specifically, where you used to be able to say
"Rat:42" you must instead say "Rat:42.0". This change affects not just
"Rat" value literals but also "Instant", "Duration", and "UTC"/"Float"
versions of the latter. This change was made partly to aid code
self-documentation and syntax highlighting, as well as support a
subsequent change item (unqualified value literals).
* (HDMD_Perl[5|6]_Tiny.pod) Updates corresponding to previous change
item, as was appropriate for each Perl version.
* (PTMD_Tiny.pod) Updated the "blob_payload" grammar token so that the
string must be quoted rather than unquoted. This change was made
partly to aid syntax highlighting, especially with the empty string, as
well as to support a subsequent change item (unqual value literals).
* (PTMD_Tiny.pod) Made "Text" and "Comment" value literals stricter
such that all of their character string segments must be quoted; now
only "Name"/etc character strings allow unquoted string segments. In
the process, did a bit of grammar refactoring that eliminated the
"char_str[|_seg]" tokens and updated the "[text|name|comment]_payload"
and "ln_base_[authority|version_number]" tokens. This change was made
to aid code readability as well as support a subsequent change item
(unqualified value literals).
* (PTMD_Tiny.pod, HDMD_Perl[5|6]_Tiny.pod) Updated the Tiny dialects
to add support for specifying generic context value literals of certain
data types as just their payloads, without explicit "value kind"
metadata; that is, added support for unqualified value literals. Which
data types this new feature is allowed to be used with varies by
dialect. With PTMD_Tiny, the 5 types [Bool, Int, Blob, Text, Rat] are
supported. With HDMD_Perl6_Tiny, the 8 types [Bool, Int, Blob, Text,
Rat, Instant, Duration, Order] are supported. With HDMD_Perl5_Tiny,
the 3 types [Int, Text, Rat] are supported, albeit less rigorously.
This change was made to aid code brevity and to make Muldis D
significantly more like typical programming languages in regards to how
one writes character string or numeric literals; in fact those formats
are now exactly the same in general. Most example code was updated to
the new terse format, with typically just one example per type
remaining in the old fully qualified format. No grammar tokens were
added, just some were changed.
* (Routines.pod, Ordered.pod, Integer.pod) Added the 6 new functions
["sys.std.Core.QRelation.[restriction_and_cmpl|semijoin_and_diff]",
"sys.std.Ordered.[|maybe_]minmax",
"sys.std.Integer.[|maybe_]quotient_and_remainder"]; each of these is
just a wrapper over a pair of other mutually complementary functions.
* (QRelation.pod) Added new function
"sys.std.QRelation.classification" which is sort of a cross between
"restriction" and "group"; it uses a user-defined function argument to
partition a q/relation's tuples into an arbitrary number of groups.
2009-03-13 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.61.0 is released on CPAN as
Muldis-D-0.61.0.tar.gz.
* A Friday the 13th release.
* (HDMD_Perl6_Tiny.pod) Corrected the new Instant|Duration value
literals to say that their payloads are simply Perl 6 Instant and
Duration values, which are directly mapped, same as with value literals
for [Bool, Int, Blob, Text, Rat, Name, Comment, Order] etc. The
previous descs saying to use Rat payloads only applied for Perl 5 Tiny.
* (Basics.pod, Types.pod, Types_Catalog.pod, Routines.pod) Updated the
core type "Int" so it is no longer a primitive type but rather now is a
structure type, which is defined in terms of a single-element "String"
attribute; also added new core type "sys.std.Core.Type.SEString", a
subtype of "String", for use in defining the updated "Int". Also found
any other references to the "Int" type that said it was primitive or
had no possreps etc and updated them.
* (Basics.pod, Types.pod, Types_Catalog.pod, Routines.pod) Updated the
core type "String" so it is no longer a primitive type but rather now
is an enumeration type, which is implicitly defined in terms of a union
over an infinite number of implicitly defined
"sys.std.Core.Type.String.*"-named singleton structure types, each one
being named with its value. To support the infinite new implicit
types, updated the "Name" type so its sole possrep's sole attribute is
now "String" typed, rather than being "UCPString" typed like "Text".
However, actual user exploitation of the new flexibility of "Name" is
strongly discouraged, to the point that all of the standard Muldis D
dialects remain unchanged and so "Name" value literals still only
support what is supported for "Text", and one can only select one of
the newer "Name" values by way of a "Scalar" value literal plus a
"String" value literal. Also found any other references to the
"String" type that said it was primitive or had no possreps etc and
updated them.
* Following the last 2 change items, Muldis D has only 2 "primitive"
types left, which are "QTuple" and "QRelation". Moreover, Muldis D no
longer has the concept of q/scalar root type with no possreps; all
system-defined or otherwise q/scalar values now have 1/+ possreps.
* (Routines.pod, QTuple.pod, QRelation.pod) Updated all 15 functions
and 5 updaters that had a "set_of.Name"-typed parameter named
"[|\w+_]attrs" and renamed said parameter to "[|\w+_]attr_names"; any
similarly named parameters that were of some other type, such as
"QTuple", kept their old names. This change should make the parameters
more self-documenting, since "attrs" names now tend to have both
attribute names and values, where as "attr_names" have just names. The
changed 20 routines were:
"sys.std.Core.Q[Scalar|Tuple|Relation].[|cmpl_]projection",
"sys.std.Core.Q[Tuple|Relation].assign_[|cmpl_]projection",
"sys.std.Core.QRelation.[summary|[|assign_]extension]",
"sys.std.[Core.QScalar|Q[Tuple|Relation]].has_attrs",
"sys.std.QRelation.[map|substitution|subst_in_[restr|semijoin]]".
* (QRelation.pod) Added new function "sys.std.QRelation.has_key".
* (PTMD_Tiny.pod, Temporal.pod) Minor fixes.
2009-02-25 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.60.0 is released on CPAN as
Muldis-D-0.60.0.tar.gz.
* (Types.pod) Minor update to ambiguity-reduce the descriptions of 8
types; replaced the text "its cardinality is" with the text "the
cardinality of this type is"; the remaining types already used the
newer wording. Further related minor update with the 3 types [QMaybe,
Nothing, QSingle] regarding text like "is a proper subtype of" that
talks about the number of elements it has; this was updated to clarify
it is talking about how many elements each member value of the type
has, and it is not talking about how many member values the type has.
* (Types.pod, Types_Catalog.pod, Rational.pod, PTMD_Tiny.pod,
HDMD_Perl(5|6)_Tiny.pod, Basics.pod, Core.pod, Temporal.pod, D.pm, the
README file) Promoted the 6 rational numeric concerning types [Rat,
NNRat, PRat, PInt2_N, RatRound(Meth|Rule)] to the language core, where
they how have a status like Blob and Text, which is being not necessary
for bootstrapping a minimal Muldis D, but still being highly important
for user data nonetheless; this said, in the near future, Rat may
become needed by the system catalog if the latter starts storing
time-stamps. The 4 type declarations [Rat, NNRat, PRat, PInt2_N] were
moved from Rational.pod to Types.pod, and their namespace changed from
"sys.std.Rational.Type.\w+" to "sys.std.Core.Type.\w+"; the 2 type
declarations [RatRound(Meth|Rule)] were moved from Rational.pod to
Types_Catalog.pod, and their namespace changed similarly but for an
extra ".Cat"; all 6 types were exactly the same after the move, except
that the types' fully qualified names changed. After these moves,
Rational.pod has declarations for just the 3 types [BRat, DRat,
PInt2_36]; all of its routines were kept, unchanged. In each of the 3
Tiny dialect files, the literal syntax for "Rat" and "RatRoundMeth" was
moved upwards to go next to the appropriate other core scalar types,
and the main documentation section "RATIONAL EXTENSION SCALAR VALUE
LITERALS" no longer exists. Any other files that referred to rational
types or the rational extension were appropriately updated.
* (Temporal.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod) Renamed the
type "sys.std.Temporal.Type.Duration" to
"sys.std.Temporal.Type.UTCDuration", in order to avoid a short-name
conflict with an upcoming new type. Also correspondingly renamed the
"sys.std.Temporal.Duration.\w+" namespace. For each of the Tiny
dialects, also renamed the corresponding value literal node name from
'Duration' to 'UTCDuration'. In PTMD_Tiny.pod, renamed the 4 tokens
"(instant|duration)(|_payload)" to prepend "utc_".
* (Types.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod) Added the 2 new
scalar types "sys.std.Core.Type.(Instant|Duration)" to the language
core (Types.pod) and added corresponding special value literal syntax
for them to all the Tiny dialects. Unlike the existing types in
Temporal.pod, which are focused more on calendar-based artifacts with
distinct YMDHIS components and will DWIM with future dates, the new,
disjoint types in Types.pod are simply counts of seconds in the TAI
time scale, and are now the recommended types for tasks like timestamps
or benchmarks or scientific applications. The representation of each
of these 2 new types is a rational numeric, and their Tiny literal
syntax is exactly the same as for 'Rat' save for the different
[Instant, Duration] value kind. Within the language core, the 2 new
types have the same status as 'Rat', which is being not necessary for
bootstrapping a minimal Muldis D, but still being highly important for
user data nonetheless; this said, in the near future, at least
'Instant' may become needed by the system catalog if the latter starts
storing time-stamps.
* (Temporal.pod) Added an initial complement of 7 new functions
"sys.std.Temporal.Instant.((|abs_)difference|later|earlier)",
"sys.std.Temporal.Duration.(abs|sum|difference)" and 1 new system
service "sys.std.Temporal.Instant.fetch_current_instant" to go with the
new core language "Instant" and "Duration" types as used in isolation
from the additional types that Temporal.pod declares.
* (Temporal.pod) Added an initial complement of 2 new functions
"sys.std.Temporal.UTCInstant.(UTC_from_TAI|TAI_from_UTC)", in the new
main documentation section "FUNCTIONS FOR CONVERSION BETWEEN UTC AND
TAI", which are for mapping "Instant" and "UTCDateTime" values.
* (Basics.pod, Routines.pod, Rational.pod, Temporal.pod) Minor updates
and fixes.
2009-02-07 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.59.1 is released on CPAN as
Muldis-D-0.59.1.tar.gz.
* (Routines.pod, Routines_Catalog.pod, Ordered.pod, Integer.pod,
Blob.pod, Text.pod, QTuple.pod, QRelation.pod, QSet.pod, QArray.pod,
QBag.pod, Rational.pod, Temporal.pod) Some POD reformatting: Took
what used to be some level-2 headings that grouped lists of routines
and changed said into level-1 headings, but did not uppercase their
text. Then converted the routine lists from being "=over/=item
<routine>/=back" to each routine having its own level-2 heading. For
each routine, the new heading is just the (fully-qualified) name of the
routine, and the full signature of the routine displays just as its own
paragraph. All these changes combined should look visually like we are
faking 3 levels of headings, with top and middle being upcased and
mixed case "=head1" respectively.
* (Spatial.pod) Did similar to the previous change item but with the
type list in Spatial.pod, so that is now formatted like all the other
type lists in the spec, with a level-2 heading per type.
2009-02-07 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.59.0 is released on CPAN as
Muldis-D-0.59.0.tar.gz.
* This release features a set of smaller language enhancements that
were inspired during development of the module Set::Relation version
0.5.0 for Perl 5. Set::Relation 0.5.0 also inspired plans for other
language enhancements but those have been deferred to a future release.
* (QRelation.pod) Renamed the 10 "sys.std.QRelation."-namespace
routines ["(|assign_)(|static_)substitution_in_(restriction|semijoin)",
"outer_join_with_(|static_)extension"] to the much shorter
abbreviations ["(|assign_)(|static_)subst_in_(restr|semijoin)",
"outer_join_with_(|static_)exten"], so they are easier to type.
* (QRelation.pod) Updated each of the 3 functions
"sys.std.QRelation.subst(|_in_(restr|semijoin))" to add the 1
non-optional parameter "(|subst_)attrs", which lets the user spell out
exactly which topic attrs are the ones that may be getting their values
updated by the closure argument; while not strictly necessary, this
extra constraint should force any use of each function to be more
predictable and easier to implement.
* (QTuple.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod) Renamed the 1
function "sys.std.QTuple.substitution_in_default" to
"sys.std.QTuple.subst_in_default".
* (Basics.pod, Types.pod, Routines.pod, QRelation.pod, QSet.pod) A few
minor description updates or fixes.
* (README, D.pm) Added mentions of Set::Relation in SUPPORT/FORUMS.
* Updated all files with a "LICENSE AND COPYRIGHT" documentation
section to change the Copyright declaration from "Darren Duncan" to
"Muldis Data Systems, Inc." (which is wholly owned by Darren Duncan).
2009-01-19 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.58.0 is released on CPAN as
Muldis-D-0.58.0.tar.gz.
* This release features a set of smaller language enhancements that
were inspired during development of the module Set::Relation version
0.0.0 for Perl 5. These 2 releases were made in tandem.
* (PTMD_Tiny.pod) Renamed the grammar token "nc_elem_sep" to
"name_chain_elem_sep" and refactored it to embed optional whitespace.
* (Basics.pod, Routines_Catalog.pod) A few minor fixes.
* (Routines.pod, QRelation.pod) Updated the 4 routines
["sys.std.Core.QRelation.((|assign_)extension|summary)",
"sys.std.QRelation.map"] to add a "attrs" parameter; this is necessary
in the general case where the "topic" parameter may have zero q/tuples,
meaning the function that would otherwise define the added/result attrs
wouldn't be invoked and said new attributes are not otherwise known.
* (Routines.pod, QRelation.pod) Added 1 routine
"sys.std.Core.QTuple.static_extension" (dyadic version of "product"),
renamed "sys.std.Core.QTuple.assign_product" to
"assign_static_extension" (and its param "other" to "attrs"), and
renamed "sys.std.QRelation.outer_join_with_product" to
"outer_join_with_static_extension"; the new names are easier to
understand, and the name "product" is saved for just N-adic operators.
Also renamed the "sys.std.QRelation.composition" parameters from
"r1|r2" to "topic|other".
* (QRelation.pod) Added the 2 new relational operators
"is(|_not)_disjoint", which test if the intersection of their 2
arguments is/is-not empty.
* (QTuple.pod, QRelation.pod) Added the 4 new relational operators
"sys.std.Q(Tuple|Relation).is(|_not)_nullary", which complement the 2
"is(|_not)_empty" operators; they test if the sole argument has zero
attributes or not.
* (Routines.pod, QRelation.pod) A few minor description updates.
* (SeeAlso.pod) Updated the "CURRENT IMPLEMENTATIONS OF MULDIS D" main
section to add 2 new items, which are the Set::Relation module for Perl
5 and Perl 6 respectively.
2009-01-08 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.57.0 is released on CPAN as
Muldis-D-0.57.0.tar.gz.
* (Types_Catalog.pod) Eliminated the "SysScaNPRTypeSet" type and the
"System" type's "sca_npr_types" attribute; their role of declaring the
2 types 'Int' and 'String' will now be handled by the "SysSpecTypeSet"
type and "special_types" attribute.
* (Routines_Catalog.pod) Refactored the 2 pod sections "Procedures For
Defining (Routines|Data Types)" into 2 alternate pod sections
"Procedures For Defining (Depot|Package) Routines and Data Types";
there were no changes to the 8 there-declared procedures themselves.
* (Basics.pod, Types_Catalog.pod, Routines_Catalog.pod) Added new
language concept of "topic namespaces", which is analogous to the
frequently used SQL DBMS (or general purpose language) concept of a
"current database|schema" (or current class etc). In Basics.pod, added
new primary namespace "tpc" ("topic"), and added new pod sub-section
under "ENTITY NAMES" called "Time-Varying Topic Namespaces" which
explains the new feature. In Types_Catalog.pod, added new data type
"sys.std.Core.Type.Cat.TopicNSControlCat" (for "tpc.cat") in new main
pod section "TYPES FOR DEFINING TOPIC NAMESPACE CONTROLS". In
Routines_Catalog.pod, added new procedure
"sys.std.Core.Cat.select_topic_namespaces" in new pod sub-section
"Procedures For Defining Topic Namespaces"; also updated the previously
existing 12 "create|drop" procedures for in-depot namespaces and
routines and types so they no longer have explicit parent
namespace-specifying parameters; instead, users must now set an
appropriate topic namespace before invoking any of those "create|drop"
routines, as the topic namespace now is the implicit topic namespace of
the entity to create|drop.
* (HDMD_Perl(6|5)_Tiny.pod) Reorganized some pod sections, but did not
make any language changes. Merged the 2 pod main sections "CORE
GENERIC NONSCALAR VALUES" and "QUASI- VALUES" into the 1 "GENERIC
Q/SCALAR AND Q/NONSCALAR VALUE LITERALS", which also had the
"sys.std.Core.Type.Scalar" sub-section moved to it; quasi and non-quasi
variants of the same node kind are now described together. Merged the
2 pod main sections "CORE GENERIC SCALAR VALUES" and "CATALOG SCALAR
VALUES" into the 1 "SIMPLE CORE SCALAR VALUE LITERALS". Merged the 2
"Instant" pod sub-sections into one. Moved the 2 "BOOTLOADER" sections
downward to just previous of the "PRAGMAS" section. Renamed the 2
"EXTENSION" main sections to replace "VALUES" with "VALUE LITERALS".
* (PTMD_Tiny.pod, HDMD_Perl(6|5)_Tiny.pod) Renamed the concept
"bootloader imperative routine call" to "bootloader statement"; the
corresponding node kind was renamed from "boot_call" to "boot_stmt";
the main pod section for it was likewise renamed.
* (PTMD_Tiny.pod) Added pod main section "MULDIS D TINY DIALECT
PRAGMAS" which is simply a clone of the one in HDMD_Perl(6|5)_Tiny.pod;
in any event, that whole section as we know it now is deprecated.
* (PTMD_Tiny.pod) Refactored some grammar tokens, but did not make any
language changes. Split "language_name" into itself and
"ln_base_name"; renamed "ln_authority" to "ln_base_authority", and
"ln_version" to "ln_base_version_number". Renamed "literal" to
"value". Renamed "val_(node|payload)_elem_sep" to
"value_(node|payload)_elem_sep". Renamed all "foo_or_qv" tokens to
"qfoo". Changed any "[Q]?" grammar fossils to "Q?".
* (PTMD_Tiny.pod) Reorganized all the grammar tokens and code
examples, but did not make any language changes. The old 2 pod main
sections "GRAMMAR OF TINY PLAIN TEXT MULDIS D" and "EXAMPLES" were
replaced with 8 main sections having 22 sub-sections, of which 7 / 22
correspond directly to those same-named in HDMD_Perl(6|5)_Tiny.pod (1
"LANGUAGE NAME", 4 "VALUE LITERALS", 2 "BOOTLOADER); the 8th new main
section was "VALUE LITERAL COMMON ELEMENTS". Following this change,
all Tiny.pod files now keep related grammar and code examples together.
* (PTMD_Tiny.pod) Fleshed out the "VALUE LITERAL COMMON ELEMENTS" pod
main section, so that it now supersedes the kind of information in the
"GENERAL STRUCTURE" section of HDMD_Perl(6|5)_Tiny.pod; the latter will
be stripped later. Cloned and split the "value" token into itself plus
the 2 new "value_kind" and "payload" tokens; there are now 2 versions
of "value" in this section, showing things from different angles. Also
split the 3 tokens "(bool|order|rat_round_meth)" into themselves and 3
additional "(bool|order|rat_round_meth)_payload".
* (PTMD_Tiny.pod) Added example code to the "BOOTLOADER" section which
mimics the corresponding example code in HDMD_Perl(6|5)_Tiny.pod.
* Incremented all copyright year range-ends to 2009.
2008-12-27 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.56.0 is released on CPAN as
Muldis-D-0.56.0.tar.gz.
* This release features a snapshot of progress in rewriting the 3
Muldis D dialect definitions so that, on completion of the rewrite, the
Tiny Plain Text Muldis D dialect is now treated as the primary one,
having the primary details and being self-sufficient, and the 2 Tiny
Perl Hosted Data dialects are then delta documents of that one; prior
to the rewrite, the reverse was true. This rewrite is expected to be
completed over the next 1-2 releases.
* (PTMD_Tiny.pod, HDMD_Perl(6|5)_Tiny.pod) Rewrote most of the
DESCRIPTION pod sections for each of the 3 files, and added a new
GENERAL STRUCTURE main section to PTMD_Tiny.pod. Also added a brief
main pod section REWRITE PROGRESS MARKER to all 3 files to demark
approximately the post-rewrite from pre-rewrite content. There wasn't
really anything removed or altered yet save the DESCRIPTION sections.
* (Basics.pod) Added TODO note in TYPE SYSTEM that a feature akin to
Perl 6 roles, which could be used to provide a quasi-"specialization by
extension" language feature, might be added in the future.
* (Basics.pod) Made various smaller edits to the TYPE SYSTEM main and
sub-sections, for clarity or to further clean up the results of the
quasi- made supertypes thing. Updated the concept of 'scalar type' to
say that not just a minimum of one but rather all of the possreps of a
scalar may have only non-quasi attributes. The concepts 'tuple type'
and 'relation type' have been tightened to mean exactly what TTM says;
all nonscalar types have fully-defined attribute lists; the ['Tuple',
'Database', 'Relation', 'Array'] etc types are now actually
quasi-nonscalar types even though all their values are non-quasi
nonscalar. The concept of 'remnant type' has been restricted to just
mean a type drawing values from at least 2 of sca/tup/rel/ref; other
prior uses of 'remnant type' such as for combinations of 'incompatible'
tuple or relation values are now simply quasi-tuple or quasi-relation
types instead; also removed the "Remnant Types" pod sub-section.
* (Basics.pod) Updated the TYPE SYSTEM main section to say that Muldis
D now *does* enforce single MSTs for q/scalar types, just between those
that declare possreps. While Muldis D doesn't require this to absolve
ambiguity in general, it simply seemed like a good idea, and targeted
the main kind of circumstance that TTM cares about with its MST rule.
* (Types.pod) A couple small pod format fixes.
* (Basics.pod, Types.pod, Routines.pod, Types_Catalog.pod) Reduced any
mentions of the concepts 'complete type' and 'incomplete|parameterized
type'. Also, now only quasi-nonscalar types can be incomplete, and
also now just the sys-def types that don't list any attributes, like
'Database', are called incomplete; by contrast, 'Array' and such are
now called 'complete' (declaring all attrs, even if 'value' is
'Universal'). Also updated the 'InnerScalarType' and 'InnerRestrType'
type descriptions concerning what you can or can't use to define an
incomplete type with.
* (Routines.pod, QTuple.pod, QRelation.pod) Added some basic value
introspection functions which could be used in definitions of generic
union or restriction types that aren't defined in terms of attribute
lists, including the system-defined 'Relation' etc which are now
defined in terms of 'QRelation' etc. In Routines.pod, added the 5
functions "sys.std.Core.QScalar.(has_possrep|possrep_names)" and
"sys.std.Core.QScalar.(degree|has_attrs|attr_names)"; between
QTuple.pod and QRelation.pod, added the 4 functions
"sys.std.Q(Tuple|Relation).(has_attrs|attr_names)".
* (Routines.pod) Updated the 2 functions
"sys.std.Core.QScalar.(|update_)attr" to make the 'name' parameter
optional; like 'possrep', its argument defaults to the empty string if
not given. This seemed like a good idea since a lot of built-in
scalar-with-possrep types have a single attribute per possrep with the
empty name, and many simple user-def ones likely would also.
* (Basics.pod, Types.pod) Added new generic reference type "External"
(a proper subtype of "Reference") to which belong any black-box values
that result when a peer or host language, like Perl, wants to hand off
any arbitrary value or object to Muldis D to hold onto for awhile, such
as if Perl wants to organize arbitrary things in relations; those
values are disjoint from all native-to-Muldis D values; these values
are only transient and can't be kept in a database.
2008-12-19 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.55.0 is released on CPAN as
Muldis-D-0.55.0.tar.gz.
* This release features the first rough cut of a reorganization of the
Muldis D type system such that the quasi-(scalar|tuple|relation) types
are now proper supertypes of the scalar|tuple|relation types, rather
than the 2 groups being disjoint yet very similar. As part of this
change, all of the generic scalar|tuple|relation operators have been
made more liberal so to handle the quasi- supertypes natively; but
their behaviour is unchanged when given arguments that were valid
before, so these changes are essentially backwards compatible.
* (PTMD_Tiny.pod, HDMD_Perl6_Tiny.pod) Fixed a few fossils. In
PTMD_Tiny.pod it was a grammar syntax error; in HDMD_Perl6_Tiny.pod it
was an out-dated code example.
* (Basics.pod, Routines.pod, Types_Catalog.pod) Fixed one fossil per
file regarding the declared type of 'assuming' parameters; each one
said the parameter was a tuple but it has actually been a quasi-tuple
for awhile now.
* (Types.pod, Integer.pod, Blob.pod, Rational.pod, Temporal.pod) Fixed
all occurrences of the common documentation/grammar error in type
definitions that said "a/an <foo-type> is a subtype of <bar-type>" by
removing the leading "a/an"; the "a/an" designates a value, where we
wanted to designate a type.
* (QRelation.pod) Added new updater "sys.std.QRelation.assign_empty"
which is analogous to a SQL "TRUNCATE" statement.
* (Types.pod, Basics.pod, Routines.pod, Types_Catalog.pod,
PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod, Ordered.pod, QSet.pod,
QRelation.pod, QArray.pod, QBag.pod) In Types.pod, renamed all 12
Quasi- type declarations
"sys.std.Core.Type.Quasi(Scalar|ScalarDVPT|Tuple(|D0)|Relation(|D0))"
and "sys.std.Core.Type.Quasi(Set|Maybe|Nothing|Single|Array|Bag)",
replacing the "Quasi" prefix with "Q". In all 12 files,
correspondingly updated all references to those types.
* (Types.pod, PTMD_Tiny.pod, HDMD_Perl(5|6)_Tiny.pod) Deleted the 4
core types
"sys.std.Core.Type.Q(ScalarDVPT|(Tuple|Relation)D0|Nothing)", and their
corresponding special Tiny literal syntaxes. Renamed the text-Tiny
token "nothing_or_qv" to "nothing". Updated the QScalar type
declaration to not give a default value, giving it one is TODO next.
* (Basics.pod) Multiple updates to the TYPE SYSTEM main pod section.
The 'Tuple' and 'Relation' types are no longer primitives but rather
are now enumerations, of 'QTuple' and 'QRelation' values. Under "Type
Identification": Non-ref type system values are now all in 3 disjoint
categories rather than 6, the 3 quasi- ones, with the 3 non-quasi now
being subsets rather than disjoint. Renamed the "Scalar Types" pod
section to "Q/Scalar Types", the "Tuple Types and Relation Types" pod
section to "Q/Tuple Types and Q/Relation Types", and the "Quasi- Types"
pod section to "Distinction of Quasi- Types from Non-Quasi Types".
* (Basics.pod) Completely rewrote the previous-mentioned
"Distinction..." section, so it now defines non-quasi types in concise
terms of quasi- types plus a simple restriction ... the distinction is
that with non-quasi types you can recursively ungroup/unwrap all
attributes down to scalars, whereas with other quasi- types you can't.
* (Types.pod) Merged the 4 main documentation sections "SYSTEM-DEFINED
CORE (|QUASI-)(|NON)SCALAR PARAMETERIZED DATA TYPES" into the 2 main
documentation sections "SYSTEM-DEFINED CORE QUASI-/(|NON)SCALAR
PARAMETERIZED DATA TYPES" and arranged all the type declarations such
that each 2 similarly named (one quasi-, one not) types appear
together, the parent quasi- type first. Within each pair, the quasi-
parent type now contains most of the descriptive details the pair has
in common, and the non-quasi one now specifies it is a proper subtype.
Also reorganized the TYPE SUMMARY documentation section to reflect the
new type hierarchy. Also updated the QScalar type declaration to say
its default value is now the same as Scalar and Bool.
* (Types_Catalog.pod) Updated the TYPE SUMMARY pod section to add the
3 nodes Q(Scalar|Tuple|Relation) to the tree between Universal and
Scalar|Tuple|Relation. Also updated the description of the
'special_types' attribute of the 'System' catalog type to remove
'Scalar|Tuple|Relation' from the list, leaving just 11 items; said 3
types will instead be declared under the 'types' attribute of 'System',
as they now have a type definition format like what users can declare.
Also updated any mentions, in various catalog entity descriptions, of
tuple|scalar|relation values or types to add the prefix "q/" where
either those or their more general quasi- types are applicable.
* (Types_Catalog.pod) Updated these 6 catalog types to remove each
type's "is_quasi" boolean/maybe-of-bool attribute: "SysScaNPRTypeSet",
"(ScaPR|Tup|Rel)LitExprNodeSet", "Inner(S|Nons)calarType". In the case
of "SysScaNPRTypeSet", there are no longer any system-defined
no-possrep types that aren't scalar. As for the rest, whether they are
non-quasi or not will be determined by looking at each type's
attributes' type definitions, essentially the same work as is done with
union etc types.
* (Integer.pod, Blob.pod, Rational.pod, Temporal.pod, Spatial.pod) In
these, the 5 language extension files that declare data types, updated
each file's TYPE SUMMARY pod section to add the single QScalar node to
the tree between Universal and Scalar; in just Rational.pod, also added
the single QTuple node between Universal and Tuple.
* (Routines.pod, Ordered.pod, QTuple.pod, QRelation.pod, QSet.pod,
QBag.pod, QArray.pod) Updated all the generic relational operators and
other generic scalar or nonscalar operators to gain savvy with the
wider quasi- versions of the types they handled before. These still
have the same semantics as before with non-quasi values that worked
before. Generally speaking, any declared result or parameter types of
"Scalar|Tuple|Relation|Set|Maybe|Single|Array|Bag" have now been
changed to "QScalar" etc; also, all declared result or parameter types
of "ScaTupRel" have been changed to "Universal". (So the "ScaTupRel"
type is no longer used in any system-defined entity signatures, but it
continues to be declared for the convenience of user-defined entities.)
Also any "(set|maybe|single|array|bag)_of" type prefixes attached to a
now-Q-type result or parameter type declaration have been changed to
"quasi_\w+_of" versions.
* (Routines.pod, QTuple.pod, QSet.pod, QArray.pod, QBag.pod,
QRelation.pod) Related to the previous changes, to make their names
more accurate, 15 routines were renamed to
["sys.std.Core.QScalar.(QTuple_from_QScalar|QScalar_from_QTuple)",
"sys.std.Core.QRelation.(QTuple_from_QRelation|QRelation_from_QTuple)",
"sys.std.QTuple.(attr_from_QTuple|QTuple_from_attr)",
"sys.std.QSet.QSet_from_(wrap|attr)",
"sys.std.QArray.(QArray_from_(wrap|attr)|limit_of_QArray_from_wrap)",
"sys.std.QBag.(QSet_from_QBag|QBag_from_(QSet|wrap|attr))"] from the
same names but lacking any "Q".
* (Routines.pod) Updated the descriptions of the 2 routines
"sys.std.Core.QRelation.un(wrap|group)" to specify that they would fail
with certain quasi-relation arguments due to their TVAs or RVAs not
having consistent attribute sets (a problem that non-quasi relations
never have, by definition).
* (Routines.pod, QSet.pod, QArray.pod) Updated the descriptions of the
8 routines
["sys.std.Core.QRelation.(is_(member|subset)|difference|join)",
"sys.std.QSet.is_member",
"sys.std.QArray.(update_value|insertion|is_element)"] so that they now
warn rather than die on type incompatabilities of input relations that
would make the routine result in a general quasi-relation rather than a
relation. Note that there might be other routines needing similar
documentation updates, but the above 8 were the only ones easily
locatable by their use of the word "incompatible". In fact, most
routines were simply silent on the matter, the behaviour being implied.
* (Core.pod, Routines_Catalog.pod, Conventions.pod) Minor entity
description updates re quasi-/non merge.
2008-12-16 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.54.0 is released on CPAN as
Muldis-D-0.54.0.tar.gz.
* This release features the first rough cut of a split in the Perl
Hosted Data Muldis D dialect into separate versions for Perl 6 and Perl
5 where each is optimized for its mutually very distinct host, making
heavy use of features from one version that aren't in the other. Or
technically, the split was largely done in release 0.53.0, where
HDMD_Perl_Tiny.pod gained disjoint descriptions between Perl 6 and Perl
5 hosts for almost everything; this current release mainly just
separates those into distinct files.
* (HDMD_Perl6_Tiny.pod, HDMD_Perl5_Tiny.pod, D.pm, Basics.pod,
Types.pod, PTMD_Tiny.pod, README) Cloned the 1 file HDMD_Perl_Tiny.pod
once and renamed the original and copy into HDMD_Perl(6|5)_Tiny.pod
respectively. Updated each copy so it excludes the details not
relevant to its now single host language, and further tweaks the
remaining more generic text to become more specialized. Updated all
other distro files that referred to the old 1 file so they refer to the
new 2 instead.
* This release also has the first step of rearranging the Muldis D type
hierarchy to make the quasi- types into proper supertypes of their
non-quasi namesakes, rather than disjoint but similar types. The
primary change now is renaming some files, but otherwise leaving
related changes minimal; the main changes will be done in the next
release, so that it would be easy to diff the important changes without
having to deal with the complexity of simultaneous file name changes.
* (QTuple.pod, QRelation.pod, QSet.pod, QArray.pod, QBag.pod, D.pm,
Core.pod, README) Renamed the 5 files [Tuple.pod, Relation.pod,
Set.pod, Array.pod, Bag.pod] to add a 'Q' prefix. Updated all other
distro files that referred to the old file names so they refer to the
new ones instead.
* (Routines.pod, QTuple.pod, QRelation.pod, QSet.pod, QArray.pod,
QBag.pod, Basics.pod, Types_Catalog.pod, HDMD_Perl(6|5)_Tiny.pod,
Ordered.pod) Renamed all "sys.std.Core.(Scalar|Tuple|Relation).\w+"
entities to "sys.std.Core.Q(Scalar|Tuple|Relation).\w+", and all
"sys.std.(Tuple|Relation|Set(|.Maybe)|Array|Bag).\w+" entities to
"sys.std.Q(Tuple|Relation|Set(|.QMaybe)|Array|Bag).\w+".
2008-12-15 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.53.0 is released on CPAN as
Muldis-D-0.53.0.tar.gz.
* (Basics.pod, Types.pod, Types_Catalog.pod, Routines.pod,
Routines_Catalog.pod, HDMD_Perl_Tiny.pod, Conventions.pod, Ordered.pod,
Tuple.pod, Relation.pod, Set.pod, Array.pod, Bag.pod, Rational.pod)
Updated all distro files that referred to catalog types using their
unqualified name so to remove the 'Cat.' prefix; now the unqualified
references for all system-defined types are just spelled 'Foo' and the
catalog types are no longer special case spelled 'Cat.Foo'.
* (Types.pod, Blob.pod) In Types.pod, added new proper subtype of
'Blob' named 'OctetBlob' whose string lengths are a multiple of 8 bits,
and that subtype added a new possrep 'octets'. This new subtype is for
convenience of users since most user Blob values will likely consist of
whole octets and users would probably like to deal in those terms.
Also added new 'String' subtype 'OString' in the same file. In
Blob.pod, renamed the 2 functions "is_(|not_)_substr" to
"is_(|not_)_substr_bits" and added the 3 new functions
"length_in_octets" and "is_(|not_)_substr_octets".
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Fixed a widespread Perl 6
grammar mistake in PTMD_Tiny.pod; with character classes defined as a
range between 2 characters, the endpoints of the range are actually
separated by a double period (which is generic Perl range literal
syntax), not a single hyphen like in Perl 5. Likewise updated the
string format syntax in HDMD_Perl_Tiny.pod.
* (HDMD_Perl_Tiny.pod) Renamed the concept "node type" to "node kind",
to help avoid possible confusion with the concept of a data type name.
* (PTMD_Tiny.pod) Renamed the 4 grammar tokens "text_str",
"(|(|non)quoted_)text_str_seg" to replace any "text" for "char, since
they're also used for Name and Comment etc. Renamed the token
"list_sep" to "list_elem_sep" and "pair_sep" to "pair_elem_sep". The
token "scalar_type_name" was merged into "type_name".
* (Types_Catalog.pod) Updated the NameChain and DeclNameChain types to
eliminate their "flat" possreps, leaving just their "array" possreps;
the concept of a "flat" possrep has been demoted and can now just be
provided by individual dialects in their proprietary manners instead.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Updated both Tiny dialects to
simplify the literal formats for NameChain and DeclNameChain values.
With PTMD_Tiny, you can't put a whole (multi-part) chain in a single
pair of bracket or quote delimiters anymore; instead, each kind of
chain is just expressed as a non-delimited chain of period-separated
Name-formatted elements; only each element can be either a bareword or
a quote-delimited string; now, literal period characters in chain
elements are never escaped; now, DeclNameChain are formatted exactly
the same as NameChain, without any leading/trailing periods. With
HDMD_Perl_Tiny, eliminated all Muldis D specific character escaping;
now, if you want to have literal perod characters in chain elements,
then you must use the Array payload format; also an empty string in the
string payload format now means a single-element DeclNameChain; you
must use the Array payload format to represent a zero-element chain.
In PTMD_Tiny, merged the 5 grammar tokens "(|d)nc_(array|flat)" and
"nc_char" into the 2 "(|decl_)name_chain_body" and then merged the 2
grammar tokens "text_(delim|char)" into the 1 "quoted_char_str_seg".
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Further standardized the formats
and generic features of Muldis D value literals in both Tiny formats so
that literals are more intuitive to write and easier to parse or
generate. Now, every value literal has 1-3 main parts, which are the
node kind, a usually optional type name, and a usually mandatory
payload. Previously, most scalar typed literals didn't take an
(optional) explicit subtype name like nonscalar typed literals did, but
now they do. Any old 1+ main literal parts besides the node kind and
optional type name are now all collectively part of the payload under
the new design. In PTMD_Tiny, the 'spec_sep' token has been split into
the 2 tokens 'val_(node|payload)_elem_sep', the first new one being a
colon character like the old one, and the second new one being a
semicolon character; the first new one is used to separate the 1-3 main
parts of a value literal, and the second is used to separate any
multiplicity of payload parts that some payloads might have. In
HDMD_Perl_Tiny, the main documentation has been refactored so that the
GENERAL STRUCTURE pod section now describes the 1-3 main PHMD node
parts on behalf of all node kinds, and the pod sections specific to
each node kind have now been simplified to just describe the new
payloads; where the old PHMD node had just 1 element besides node kind
and optional type name, the new payload is exactly the same; where the
old PHMD node had possibly multiple (typically 1 or 2) elements besides
the node kind and type name, the new payload is an Array|Seq having
those same 1 or 2 elements (the old 'payload' was renamed, typically to
'main payload'); any further refactoring on this matter is described in
other change items. The main PHMD node is an Array|Seq in the general
case but if a node would have 2 elements (no type name is present),
then in Perl 6 there is now the option to use a Perl 6 Pair for the
PHMD node instead.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Updated PTMD_Tiny to support an
alternative more terse syntax for base-10 numeric literals; you can now
write a numeric literal without an explicit max-col-val specifier,
which is interpreted the same as an explicit max-col-val of '9'
(HDMD_Perl_Tiny already supported this terse form before). Both Tiny
files had their examples updated to use the terse syntax for literals
that were explicitly base-10 before. Also added a couple more 'Rat'
examples in PTMD_Tiny.
* (PTMD_Tiny.pod) Refactored all the tokens denoting value literals so
that the payload portion is always apart from the main portion, and
further standardized naming for already existing such splits.
Reorganized the 4 tokens ["relation_or_qv",
"generic_relation_(empty_body|(|non)ordered_attr)_or_qv"] into the 6
tokens ["(|generic_)relation_or_qv",
"generic_relation_(|empty_body|(|non)ordered_attr)_or_qv_payload"].
Renamed the 2 tokens "(tuple|bag)_body" to "(tuple|bag)_or_qv_payload".
Split each of these 12 tokens into itself and a same-named but for a
"_payload" suffix: "scalar_or_qv", "int", "string", "blob", "text",
"set_or_qv", "single_or_qv", "array_or_qv", "comment", "rat",
"instant", "duration". Renamed each of these 2 tokens to change the
"body" to "payload": "name_body", "name_chain_body".
* (HDMD_Perl_Tiny.pod) Forked every "Examples:" section into 2
adjacent "Perl 6|5 Examples:" sections, with each version having
identical-meaning code but with greater savvy for distinct host
language features.
* (HDMD_Perl_Tiny.pod) Updated the value literal payload formats for
the 3 types [Bool, Order, RatRoundMeth] so that the Perl 6 and Perl 5
descriptions are now disjoint. Perl 6 has been restricted so that now
the only way you can specify 'Bool' and 'Order' payloads is with their
Perl 6 native counterparts, which are 'Bool' and 'Order' objects; you
can no longer specify such payloads as Perl 6 Int or Str objects; so a
PTMD_Tiny parser in Perl 6 will now have to do more than tokenize to
Str objects. In Perl 5 you still have all the options you did before,
and these are now spelled out more clearly; you can still use all the
canonical or typical Perl 5 forms of those values, plus the string
results of a PTMD_Tiny parser in Perl 5. Since 'RatRoundMeth' has no
native equivalent types in either Perl version, you still use Str
objects or char string scalars as before.
* (HDMD_Perl_Tiny.pod) Updated the value literal payload formats for
the 7 types [Int, String, Blob, Rat, (UTC|Float)Instant, Duration] so
that the Perl 6 and Perl 5 descriptions are now disjoint. Perl 6 has
been restricted so that now the only way you can specify 'Int' and
'Blob' and 'Rat' payloads is with their Perl 6 native counterparts,
which are 'Int' and 'Blob' and 'Rat|Num|Int' objects; you can no longer
specify such literals as Perl 6 Str objects, or specify Rat payloads as
a collection of Int components; for all 7 types, you can no longer use
'Str' objects plus max-col-val metadata to get the Muldis D
implementation convert the results from a PTMD_Tiny tokenizer, but
rather you must now use the native facilities of Perl 6 to support
denoting numeric literals in any base from 2 thru 36; Perl 6 can do the
text-to-num mapping for you, and Perl 6's native numbers are "big". In
Perl 5 you still have all the options you did before, and these are now
spelled out more clearly; you can still use all the canonical or
typical Perl 5 forms of those values, plus the string results of a
PTMD_Tiny parser in Perl 5. One large further change in Perl 5 is that
you now use a 1-element hash ref to group a max-col-val (the key) with
the main payload it is metadata for (the value); this is instead of
using a 2-element array ref; this change was made so that one could
disambiguate 'Rat' payloads like "['2', '11001001']" (is the first
element a max-col-val or a numerator?) without using messy further
array nesting; it was done with all max-col-val possibly using types
for consistency and to allow further simplification and elegance. Note
that it is expected the actual use of max-col-val would be infrequent,
so huffman coding with the 'slower'/'fatter' hash refs is justified.
* (HDMD_Perl_Tiny.pod) Updated the value literal payload formats for
the 5 types [Text, (|Quasi)Tuple, (|Quasi)Array] so that the Perl 6 and
Perl 5 descriptions are now disjoint. There aren't any actual changes
or restrictions here, just clarifications.
* (HDMD_Perl_Tiny.pod) Updated the value literal payload formats for
the 4 types [(|Quasi)Set, (|Quasi)Bag] so that the Perl 6 and Perl 5
descriptions are now disjoint. Perl 6 has been restricted so that now
the only way you can specify 'Set' and 'Bag' payloads is with their
Perl 6 native counterparts, which are 'Set|KeySet' and
'Bag|KeyBag|Set|KeySet' objects; you can no longer specify such
literals as single or nested Perl 6 Seq|Array objects. In Perl 5 you
still have the same options you did before (namely single or nested
array refs), and these are now spelled out more clearly.
* (HDMD_Perl_Tiny.pod) Updated the value literal payload formats for
the 2 types "(|Quasi)Scalar" so that the Perl 6 and Perl 5 descriptions
are now disjoint. In Perl 6, the 2 elements of the payload (possrep
name and possrep attrs) are now wrapped up in a Perl 6 Pair rather than
a Seq|Array. In Perl 5, a 2 element array ref is still used.
* (HDMD_Perl_Tiny.pod) Updated the value literal payload formats for
the 2 types "(|Quasi)Relation" so that the Perl 6 and Perl 5
descriptions are now disjoint. In Perl 6, every payload now must be
either a Perl 6 Pair (ordered attrs format) or Set (named attrs
format), and can't be a Seq|Array like before; also, the value element
of that Pair must likewise be a Set; so now every part of the literal
that was conceptually unordered now actually is. In Perl 5, array refs
are still used like before.
2008-11-29 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.52.0 is released on CPAN as
Muldis-D-0.52.0.tar.gz.
* As of this release, all (non-archive) versioned files have had their
version numbers increased to match the version number of the release
itself, or in other words, to match the version number of D.pm; from
now on, all file versions will increment in lockstep regardless of
whether any actual (other) changes were made to the files in question.
This means that the meaning of the file version numbers has changed
from treating each file as a distinct document whose progress is
tracked, to being a component of the Muldis D language spec as a whole,
such that if any file is seen in isolation, it can more easily be
matched up with other files that form parts of the same Muldis D
language spec version. This also makes further updates to the spec
easier since managing many distinct version numbers was a lot more work
and error-prone; examples of such errors were that the previous 2
releases (50 and 51) both forgot to increment their changed .pod files'
internal versions like the Changes file of those releases said they
were. To see what actual changes were made to files, the individual
change items still will list them as they did before.
* (D.pm, Basics.pod, Types.pod, Routines.pod, PTMD_Tiny.pod,
HDMD_Perl_Tiny.pod, Integer.pod, Blob.pod, Text.pod, Tuple.pod,
Relation.pod, Array.pod, Bag.pod, Rational.pod, Temporal.pod) Updated
all the standard references to numbers that are zero or greater so they
are referred to as "non-negative" rather than "unsigned". Renamed the
2 generic data types "U(Int|Rat)" to "NN(Int|Rat)" and the 3
Temporal.pod specialty data types "UInt(23|59)" and "URatLT62" to
"NNInt(23|59)" and "NNRatLT62". A few plain-text Tiny grammar tokens
were likewise renamed, from a "u" prefix to a "nn" prefix.
* (Types.pod, Types_Catalog.pod) Minor misc fixes.
2008-11-29 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.51.0 is released on CPAN as
Muldis-D-0.51.0.tar.gz.
* This release serves mainly to add a new conceptually lower level
abstraction layer to the Muldis D type system such that the (unlimited
size) integer is now the only primitive scalar type, and all other
types are now explicitly defined just in terms of integers, directly or
indirectly. This release's changes are fully backwards compatible,
only adding features; the 2 exceptions being that certain subtleties of
character strings have changed, and a bit about reference types.
* New file versions are: D.pm 0.51.0 and Types_Catalog.pod 0.36.0 and
Routines.pod and PTMD_Tiny.pod 0.32.0 and Basics.pod and Rational.pod
0.30.0 and HDMD_Perl_Tiny.pod 0.29.0 and Integer.pod and Blob.pod
0.28.0 and Types.pod and Text.pod 0.27.0 and Temporal.pod 0.10.0. The
other pre-existing versioned files are unchanged.
* (Basics.pod, Types.pod, Text.pod) Updated the definition of
character strings and the 'Text' data type (and indirectly, 'Name',
'Comment', etc) to explicitly say that Muldis D works at the Unicode
codepoint abstraction level, not the grapheme abstraction level, so
what codepoints comprise a grapheme are significant for value identity.
This change was made to make Muldis D simpler to define in isolation
and more future-proofed and deterministic etc, and easier to extend
such as for locale-specific things, versus the undefined 'highest
possible' abstraction level it previously had. In Text.pod, added new
function 'length_in_codepoints' to complement the existing
'length_in_graphemes', and changed the exact meaning of the latter;
also added the 2 new functions 'folded_to_NF(C|D)' (to be generified
later), which you would use if you want to effectively work at the
grapheme abstraction level.
* (Basics.pod, Types.pod, Types_Catalog.pod) Added new union type
'sys.std.Core.Type.Reference' that is disjoint from all the
non-'Remnant' types, and updated the 4 'Func|Proc|Type|OrdDetFunc)Ref'
types so they are now in this new category and are no longer in the
quasi-scalar category (which now has no system-defined non-DVPT types).
* (Types.pod, Types_Catalog.pod, Routines.pod, PTMD_Tiny.pod)
Redefined the Bool core type so that rather than having zero possreps,
it now has 2: 'name' (a Name) with values ['false', 'true']; 'int' (an
Int) with values [0, 1]. Also updated the plain-text Tiny dialect so
that '0' and '1' are now acceptable Bool literals along with 'false'
and 'true' (no change was needed in HDMD_Perl_Tiny.pod as it already
supported 0|1). So Bool is now defined structurally and syntax-wise in
the same way as Order.
* (Types.pod, Types_Catalog.pod) Redefined the QuasiScalarDVPT core
type so that rather than having zero possreps, it now has 1, with zero
attributes.
* (Types.pod, Types_Catalog.pod, Routines.pod, PTMD_Tiny.pod,
HDMD_Perl_Tiny.pod) Added new core scalar type
'sys.std.Core.Type.String', which has zero possreps; a String is
defined as a dense sequence of 0..N (unlimited size) integers,
similarly to the primitive string types of many programming languages;
unlike Array, String is *not* defined over a Relation and its elements
can only be integers. Updated the 2 Tiny dialects so they gain special
literal syntax for String values.
* (Types.pod, Types_Catalog.pod, Routines.pod) Added new core subtype
'BString' (bit string) of String where each element must be between
zero and 1, and redefined the Blob core type so that rather than having
zero possreps, it now has 1, and Blob is now simply a wrapper over
BString having a different intended interpretation.
* (Types.pod, Types_Catalog.pod, Routines.pod) Added new core subtype
'UCPString' (Unicode codepoint string) of String where each element
must be between zero and 0x10FFFF, and redefined the 3 core types
Text|Name|Comment so that rather than having zero possreps, each now
has 1, and each of Text|Name|Comment is now simply a wrapper over
UCPString having a different intended interpretation.
* (Basics.pod) Made some large additions and changes to the TYPE
SYSTEM main documentation section of Basics.pod, primarily to declare a
new parallel type categorization system, wherein every Muldis D type is
just one of these 4 kinds, depending on how the type is defined:
primitive type, structure type, enumeration type, reference type. Also
the definition of a root type (and nonroot type) has been restated in
terms of these categories, which should be a lot more understandable.
* (Types.pod, Types_Catalog.pod, Integer.pod, Blob.pod, Rational.pod,
Temporal.pod) Annotated all the Muldis D data type definitions, either
individually or by documentation section, to say which of the above 4
categories each one belongs to.
2008-11-08 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.50.0 is released on CPAN as
Muldis-D-0.50.0.tar.gz.
* New file versions are: D.pm 0.50.0 and PTMD_Tiny.pod 0.31.0 and
HDMD_Perl_Tiny.pod 0.28.0. The other pre-existing versioned files are
unchanged.
* (D.pm) In the VERSIONING section, clarified that a Muldis D language
name can have some elements optional in documentation, in which case
the partial name refers to the whole subtree of language variants
having the specified elements in common. Also simplified the
Extensions sub-section to say that whether a 5th or subsequent elements
exists and their format varies by the dialect in use.
* (HDMD_Perl_Tiny.pod) Simplified all value literals having an
'any_perl' format hint option, namely
Bool|Int|Rat|(UTC|Float)Instant|Duration, by removing said option. So
now the most liberal Perl-specific format options are gone; however,
the more strict Perl-specific formats (that disallow whitespace for
example) that remain now allow a few more options than before. A
perl-bool in Perl 5 may now use either the number zero or the empty
string to mean false, not just the empty string.
* (HDMD_Perl_Tiny.pod) Simplified all value literals having a format
hint portion, namely
Bool|Int|Blob|Order|Rat|(UTC|Float)Instant|Duration, by removing said
format hint portion. With the numeric, blob, and temporal value
literals, the test for how to interpret the payload is based simply on
the number of node elements, which is 3 for md and 2 for perl, and the
old 3rd/4th format element was redundant now that any-perl no longer
exists. With bool and order types, that are both very short enums, we
can unambiguously determine what bool/order value was wanted by
examining the Perl data type and Perl values of the payload. Overall,
this change should eliminate another kind of tedious verbosity that was
common to Perl-Tiny code.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) In a reversal of one aspect of
release 0.20.0, updated most nonscalar value literal syntax to re-add
the then-removed explicit metadata of what specific data type the
nonscalar value is a member of, rather than it for example being a
generic relation value. But use of this metadata is now optional
rather than mandatory like in its previous incarnation. Also removed
the 'treat_as_type' lexical pragma, which is now redundant.
2008-10-07 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.49.0 is released on CPAN as
Muldis-D-0.49.0.tar.gz.
* New file versions are: D.pm 0.49.0 and PTMD_Tiny.pod 0.30.0 and
HDMD_Perl_Tiny.pod 0.27.0. The other pre-existing versioned files are
unchanged.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) In PTMD_Tiny.pod, updated
numeric-based literals to permit use of the underscore character as a
separator, which may make long numbers easier to read (eg
Int:1_000_000_000); in HDMD_Perl_Tiny.pod, made the same change
concerning 'md_\w+' formats of numeric-based literals. Note that
concerning 'perl_\w+' formats, Perl already has this support built-in.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) In a reversal of one aspect of
release 0.20.0, there is no longer special terse
syntax for 'Name' literals appearing in the position of a generic
literal; the general syntax for 'Name' literals / PHMD nodes is now
exactly the same as for 'Text' or 'Comment', such as "Name:'foo'" and
"[ 'Name', 'foo' ]" rather than plain "'foo'". On the other hand,
'Name' literals appearing in special positions where one is already
expected, such as nonscalar literal attribute names, are retaining the
terse syntax there.
* (HDMD_Perl_Tiny.pod) Simplified 'Bag' literals by removing their
format hint portion. Because 'Name' literals no longer have the
special Perl Str syntax in generic literal contexts, we can now
unambiguously interpret a 'Bag' literal payload without an external
format hint.
* (PTMD_Tiny.pod) Simplified the entire grammar by removing all
capturing parens, and the 'grammar' declaration, that a real grammar
would have, so the given syntax can be a more clear human illustration.
* (PTMD_Tiny.pod) Fixed a widespread Perl 6 grammar mistake;
non-capturing groups are actually delimited by square brackets, not
round parenthesis like in Perl 5.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) In PTMD_Tiny.pod, updated the
grammar for all comma-separated lists so that there now must not be a
trailing comma after the last list item; previously, a trailing comma
was mandatory. Note that there is no corresponding HDMD_Perl_Tiny.pod
change since trailing commas are always optional in Perl. Updated all
PTMD_Tiny.pod code samples to conform to the updated grammar, and
updated just some HDMD_Perl_Tiny.pod code samples likewise.
* (PTMD_Tiny.pod) Refactored grammar for numeric literals, adding the
2 new tokens 'pint_(head|tail)'. Also updated numeric literals so that
they may now be split into segments as per character or bit strings,
with the '~' segment separator character; useful for very long numbers.
* (PTMD_Tiny.pod) Added support for bareword / non-delimited character
string literals, mainly intended to be used for 'Name' (and NameChain
etc) literals but also useable for Text and Comment literals. A
character string may be used non-delimited iff it is non-empty and only
consists of the characters [a-zA-Z0-9_-], but allowable bareword
characters may be expanded later to include anything Unicode considers
a letter or a number. Since most DBMS entity names and attribute names
etc are likely to qualify for bareword syntax, this change helps make
Muldis D code be easier to write and more like normal languages. Also,
the 'PTMD_Tiny' 4th element of its fully qualified language name is now
always a bareword rather than always a delimited string.
2008-09-18 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.48.0 is released on CPAN as
Muldis-D-0.48.0.tar.gz.
* Fixed the version numbers inside the 2 files PTMD_Tiny.pod and
HDMD_Perl_Tiny.pod; they should have been 0.28.0 and 0.25.0
respectively in Muldis-D-0.47.0 but were mistakenly not incremented
like the Changes file of that release said they were.
* New file versions are: D.pm 0.48.0 and Routines.pod 0.31.0 and
PTMD_Tiny.pod and Rational.pod 0.29.0 and Integer.pod and Set.pod
0.27.0 and HDMD_Perl_Tiny.pod 0.26.0 and Temporal.pod 0.9.0. The other
pre-existing versioned files are unchanged.
* Updated the README file to indicate that a new public repository at
http://github.com/muldis/ is planned for the near future.
* Updated the Makefile.PL to remove the obsolete warning message about
a warning message that the POD manifyer might give.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Simplified 'Bag' literals by
removing their format hint portion when the payload portion would be
unambiguous without the hint. In PTMD_Tiny.pod, no hints are necessary
at all, so removed the ':count' and ':repeat' syntax entirely; then
refactored the 3 'bag_\w+' tokens into 4 'bag_\w+' tokens. In
HDMD_Perl_Tiny.pod, the 'bag' PHMD node type can now have either 2 or 3
elements; it must now have 2 when the payload is a Perl 6 Bag|KeyBag,
and it must still have 3 when the payload is an Array|Seq; so the
'perl_bag' hint is gone, but the 'aoa_counted' and 'array_repeated'
hints remain (because there is ambiguity between the latter 2 in the
general case when we have no hint, due to a 'name' node being a Str).
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Simplified 'Rat' literals by
removing or folding their format hint portion. In PTMD_Tiny.pod, no
hints are necessary at all, so removed the ':radix' and ':ratio' and
':float' syntax entirely; then refactored the 4
'rat(|_with_radix|_as_(ratio|float))' tokens into 2 'rat(|_body)'
tokens. In HDMD_Perl_Tiny.pod, the format hints were folded from 10 to
3 as follows: 3 'md_(radix|ratio|float)' became 1 'md_rat', 4
'perl_(rat|float|int_(ratio|float))' became 1 'perl_rat', 3
'any_perl(|_(ratio|float))' became 1 'any_perl'; also, the reference to
a Perl 6 "Float" type (which it doesn't have) was corrected to "Num".
* (Routines.pod) Removed the 2 niladic functions
"sys.std.Core.Bool.(false|true)", which are superfluous given that all
Muldis D dialects would have a dedicated syntax for Boolean literals,
which are scalars having no possreps.
* (Set.pod) Added new order-determination function
"sys.std.Set.Maybe.order" which provides a short-hand to defining
semantics analogous to SQL's "NULLS FIRST|LAST".
* (Integer.pod, Rational.pod) Added 2 dyadic functions
"sys.std.(Integer|Rational).abs_difference", each of which results in
the absolute difference between its 2 arguments.
* (Temporal.pod) As anticipated would be necessary following the
previous rewrite in release 0.34.0, rewrote the Muldis D Temporal
Extension again; the most serious issues cited after the previous
rewrite are now gone. The temporal data types, and associated
operators, are now few and generic rather than many and specialized, so
the combinatorial explosion is gone; the number of distinct types
dropped from 28 to 14, and routines from 93 to 17. The 2 previous
distinct units 'second(|s)' (int), 'fractional_second(|s)' (rat) have
been merged into the 1 distinct unit 'second(|s)' (rat). A year zero
is now supported where it previously wasn't. The concepts of multiple
time zones and daylight savings time adjustments are now gone; instead,
date-time types now just come in 2 kinds, those known to be specific to
UTC, and those that are floating and not tied to any zone; if you want
to work with time zones or DST, you must now explicitly convert to/from
UTC on input and output. The DESCRIPTION pod received some updates but
is mostly the same as before.
* (Temporal.pod) Rewrote the complement of temporal data types. In
summary, the previous 21 temporal scalar root types were replaced by 3
new temporal scalar root types plus 6 new scalar subtypes. Each new
root type declares 1 possrep and each new subtype adds 1 more possrep.
Each new root type possrep consists of 6 maybes of numerics, so the
root types can represent arbitrary precision as before, but also
represent that information on larger units is unknown while in smaller
units it is known; each subtype says that exactly certain parent
attributes are known and others are unknown (eg, just YMD or HIS are
known). For specifics: 6 '(Date|Time)To(I|S|FS)WithTZ' became 4
'UTC(Instant|DateTime|Date|Time)', 9
'(DateTo(Y|M|D|I|S|FS)|TimeTo(I|S|FS))' became 4
'Float(Instant|DateTime|Date|Time)', 6 'DurationOf(Y|M|D|I|S|FS)'
became 1 'Duration' (this last one may gain a few subtypes in the
future). Regarding the plain numeric subtypes declared by Temporal,
the 1 'NZInt' was removed and the 2 ['UInt62', 'URatLT1'] were replaced
by the 1 'URatLT62'; the 4 ['PInt(12|31)', 'UInt(23|59)'] remained
unchanged.
* (Temporal.pod) Rewrote the complement of temporal math functions and
system services. In summary, the previous 63 temporal math functions
and 30 system services were replaced by the new 11 temporal math
functions and 6 system services. For specifics: 18
'(Date|Time)To(I|S|FS)WithTZ.(difference|later|earlier)' became 4
'UTCInstant.((|abs_)difference|later|earlier)', 27
'(DateTo(Y|M|D|I|S|FS)|TimeTo(I|S|FS)).(difference|later|earlier)'
became 4 'FloatInstant.((|abs_)difference|later|earlier)', 18
'DurationOf(Y|M|D|I|S|FS).(abs|sum|difference)' became 3
'Duration.(abs|sum|difference)', 6
'DateTo(I|S|FS)WithTZ.fetch_current_date_(utc|local)' and 6
'TimeTo(I|S|FS)WithTZ.fetch_current_time_(utc|local)' became 3
'UTCInstant.fetch_current_(datetime|date|time)', 12
'DateTo(Y|M|D|I|S|FS).fetch_current_date_(utc|local)' and 6
'TimeTo(I|S|FS).fetch_current_time_(utc|local)' became 3
'FloatInstant.fetch_current_(datetime|date|time)'.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Added special syntax for value
literals of temporal data types, defined in terms of 3 new keywords or
PHMD node types: 'UTCInstant', 'FloatInstant', 'Duration'; each of
these is built from an ordered list of up to 6 elements, which are
numbers (YMDHIS). Also added 6 new example literals using the new
keywords/node-types. Also added an example generic Scalar literal
showing how to write a temporal value in terms of named/unordered
components. Also updated the example of a Single literal to contain
some other piece of text that isn't a date string.
2008-08-30 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.47.0 is released on CPAN as
Muldis-D-0.47.0.tar.gz.
* New file versions are: D.pm 0.47.0 and Routines.pod 0.30.1 and
PTMD_Tiny.pod 0.28.0 and HDMD_Perl_Tiny.pod 0.25.0. The other
pre-existing versioned files are unchanged.
* (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod) Renamed the pragma
"auto_complete" of both Tiny dialects to "auto_add_attrs".
* (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod) Added new pragma to both Tiny
dialects named "auto_unabbrev_std_names", which when turned on lets a
programmer omit leading chain elements of "Cat.NameChain" literals
referencing "sys.std"-named types and routines, so long as the
abbreviated version is unique within that namespace (with an exception
iff exactly 1 candidate is "sys.std.Core"-named). So this now makes
official a kind of optional brevity that was often done with parameter
data types in routine documentation, though not yet elsewhere, that can
cut names of types or routines down to a half or sixth of the length
they would otherwise have. Almost all of the pod additions were in
HDMD_Perl_Tiny.pod, as a new sub-section of the "MULDIS D TINY DIALECT
PRAGMAS" pod at the end; like that file's pod in general, it speaks for
both Tiny dialects. The only change in PTMD_Tiny.pod was addition of a
code sample of a Muldis D language name declaration that turned the
pragma on.
* (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod) Added new pragma to both Tiny
dialects named "auto_chains_from_names", dependent on the previous 2
pragmas being turned on, which when turned on lets a programmer write
an abbreviated-to-a-single-chain-element "Cat.NameChain" literal as a
terser "Cat.Name" literal.
* (PTMD_Tiny.pod) Fixed typos.
* (Routines.pod) Removed the placeholder main pod section
"SYSTEM-DEFINED GENERIC QUASI- FUNCTIONS"; at such point that any
routines for quasi- types are formally defined, they will just go in
language extensions rather than the language core.
2008-08-17 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.46.0 is released on CPAN as
Muldis-D-0.46.0.tar.gz.
* New file versions are: D.pm 0.46.0 and Types_Catalog.pod 0.35.0 and
Routines.pod 0.30.0 and Basics.pod 0.29.0 and PTMD_Tiny.pod 0.27.0 and
HDMD_Perl_Tiny.pod 0.24.0 and Routines_Catalog.pod 0.2.0. The other
pre-existing versioned files are unchanged.
* (Basics.pod, HDMD_Perl_Tiny.pod, PTMD_Tiny.pod) Bootloader routines
may now directly reference global variables, and can now invoke any
kind of imperative routine that has subject-to-update parameters,
including updaters. In Basics.pod, updated the 'bootloader' routine
kind description and made related updates in the ROUTINES main pod
section. With both Tiny.pod, updated the grammar and examples for
boot_call tokens/nodes so they now have distinct subject-to-update and
read-only arguments.
* (Types_Catalog.pod) Removed the partly defined "Cat.DbVar" type,
which is no longer being used. Updated the "Cat.(Depot|Package)" types
to change their "data" attribute to have the "Cat.NameChain" type
rather than "Cat.DbVar"; now, that attribute just holds the declared
name of the data type of the dbvar of the depot|package, where the type
is declared first as its own DBMS entity, or otherwise the declared
type is simply "Database". Similarly updated the type of the "catalog"
attribute of the "Cat.SysCatSet" type to a NameChain from a DbVar.
* (Basics.pod, Types_Catalog.pod) It is now optional for a
depot|subdepot|package to have a self-local dbvar, which should help
save us from some chicken and egg constraints that come into play when
one wants to do data definition of depots etc. In Basics.pod, the
"User Namespace Correspondence" pod sub-section of "ENTITY NAMES" got
some large updates. In Types_Catalog.pod, the data type of the "data"
attribute of the "Cat.(Depot|Package)" types is now a
"maybe_of.Cat.NameChain" rather than a "single_of.Cat.NameChain".
* (Routines.pod) Added a set of 9 new update operators where each is a
short-cut over a tuple|relational function plus a generic assignment of
the function's result to the main relvar argument of the function; a
subset of these correspond directly to the data-manipulation phase of
common SQL "CREATE|ALTER|DROP TABLE|VIEW" statements. These 4 updaters
were added as "sys.std.Core.Tuple.\w+":
"assign_(rename|product|(|cmpl_)projection)". These 5 updaters were
added as "sys.std.Core.Relation.\w+":
"assign_(rename|(|static_)extension|(|cmpl_)projection)".
* (Types_Catalog.pod) Updated the "Cat.Federation" type by adding a
third attribute "type_maps", which indicates the various copies of the
same type over multiple depots, such that the DBMS can then treat those
types as interchangeable, so to support cross-depot operations. Also
added the 2 new catalog types "Cat.FedTypeMap(Set|)" which define that
new attribute.
* (Routines_Catalog.pod) Grouped all the procedures under a new main
pod section "PROCEDURES FOR BOOTSTRAPPING A MULDIS D PROGRAM OR
DATABASE", where their old groupings became second-level pod sections.
Wrote an introduction to this section that outlines what the procedures
do or don't do, and explains them in the context of what a bootloader
can directly do and what it can only do indirectly by defining and
executing other routines. Removed part of the "DESCRIPTION" as now
being redundant or outdated.
* (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod) Added new/first lexical-scope
pragma to both Tiny dialects named "treat_as_type", which takes the
form of a wrapper syntax/PHMD-node that annotates the
typically-nonscalar child lexical/node with a specific data type. Used
alone, this can help with some kinds of compile-time type checking.
Used together with the "auto_complete" language-name-level pragma, this
can help determine what names and types of attributes need to be
auto-added to literals that are otherwise "just a relation|tuple" and
lack that specific metadata, such as with argument values for
bootloader-invoked routines that have "Relation" typed parameters.
* (Basics.pod, Types_Catalog.pod, PTMD_Tiny.pod) Fixed typos.
* (Basics.pod) Added a few TODO-ish comments in ENTITY NAMES
sub-sections that any references to
"sys.cat.(system|impl|mount|foreign|interp)" are out-dated; the actual
system catalog doesn't mention them, and the catalog also still has to
be updated to have a place for describing implementation specific
entities; currently "(sys|mnt).cat" describe just standard entities;
the out-dated parts are being kept as a reminder of ideas still todo.
2008-08-15 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.45.0 is released on CPAN as
Muldis-D-0.45.0.tar.gz.
* New file versions are: D.pm 0.45.0 and Types_Catalog.pod 0.34.0 and
Basics.pod and Rational.pod 0.28.0 and Types.pod and PTMD_Tiny.pod
0.26.0 and HDMD_Perl_Tiny.pod 0.23.0 and Routines_Catalog.pod 0.1.0.
The other pre-existing versioned files are unchanged.
* (D.pm) In the "VERSIONING" pod section, updated the description of
the 5th "Extensions" name part to clarify that name+value entries in it
could also be pragmas or compiler directives.
* (Basics.pod) Updated the "Terse Pseudo-Variable Syntax" sub-section
of the main pod section "ENTITY NAMES", so it now says that one can
also use that terse syntax to drill down into attributes of relations,
but that the situations where this can be used are more limited than
for tuples or scalar possreps, such as that you can just use it to
refer to the same attribute of all relation tuples at once, such as in
some constraint definitions. (Also noted there that, for now, other
parts of the Muldis D spec may ignore this new fact.)
* (Types_Catalog.pod) Muldis D now officially has the concept of a
relation having exactly one (or none) primary key, which is privileged
over other unique keys it might have. A primary key permits a tuple to
have an identity other than the sum-total of all its attributes' values
(being instead just the sum-total of its primary key attributes), so
that it is now possible to conceive that a tuple in a relation may be
"updated", rather than just be replaced with a different tuple. This
change should simplify some implementation details, such as
auto-mapping of split relvars, and it should also make transition
constraints easier to define, as often such are based on the concept of
a relvar tuple being updated. Mostly this change involved rewriting
the description of the "is_primary" attribute of the "Cat.KeySet" type;
but the "Cat.DistribKeySet" and "Cat.InnerNonscalarType" types were
also affected.
* (Types.pod, Types_Catalog.pod) Updated the various system-defined
relation types, or relation-typed attributes of other types, that were
indicated to have (unique) keys on them, so that some (in fact, most)
of those explicit keys are now explicitly privileged as primary keys
instead. For the general purpose types, just "Array" and "Bag" had
this update.
* (Types_Catalog.pod) Added a "is_base" attribute to the
"Cat.PossrepSet" type, which is an optimization hint for less
intelligent Muldis D implementations as to how they choose a physical
representation for a scalar type.
* (Types_Catalog.pod, Rational.pod) Updated the documentation for all
4 of the system-defined multiple-possrep scalar root types to indicate
that each has an implementation hint for choosing a physical
representation; the types in question are: "Cat.(|Decl)NameChain"
("flat"), "Cat.Order" ("int"), "Rat" ("float").
* (Routines_Catalog.pod) Added new function
"sys.std.Core.Cat.Order_reduction" which provides the canonical terse
way to chain multiple order determination function calls into a larger
such function, typically as the controller for when you want to sort a
relation's tuples, as per a generic SQL "ORDER BY".
* (HDMD_Perl_Tiny.pod, PTMD_Tiny.pod) Added new/first pragma to both
Tiny dialects named "auto_complete", which when turned on lets a
programmer omit specifying some attributes of literals, and those
missing ones will be automatically supplied by the parser with default
values from the relevant types. So this now makes official a kind of
optional brevity that was often done in example code that tended to cut
the size of Tiny code in half from what it otherwise would have been.
Almost all of the pod additions were in HDMD_Perl_Tiny.pod, as a new
main section "MULDIS D TINY DIALECT PRAGMAS" at the end; like that
file's pod in general, it speaks for both Tiny dialects. The only
change in PTMD_Tiny.pod was addition of a code sample of a Muldis D
language name declaration that turned the pragma on.
2008-08-12 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.44.0 is released on CPAN as
Muldis-D-0.44.0.tar.gz.
* Rounded out the Core.pod file tree by adding the new file
lib/Muldis/D/Core/Routines_Catalog.pod, which debuts at version 0.0.0;
this new file is where the core Muldis D data definition routines would
be defined. The appropriate references were added in other files
[Core.pod, the README file].
* New file versions are: D.pm 0.44.0 and Types_Catalog.pod 0.33.1 and
Routines.pod 0.29.0 and Relation.pod 0.27.0 and Text.pod 0.26.0 and
Core.pod 0.21.3. The other pre-existing versioned files are unchanged.
* (Routines.pod) Fixed the "upd_invo" routine so that its "upd_args"
parameter is non-optional, because all updaters have at least 1
subject-to-update parameter.
* (Text.pod) Muldis D now just has a single function for testing the
length of a Text value, which is "length_in_graphemes"; this replaces
the previous 4 functions "length_in_nf(c|d)_(graphs|codes)".
* (Routines.pod, Relation.pod) Added a set of 18 new update operators
where each is a short-cut over a relational function plus a generic
assignment of the function's result to the main relvar argument of the
function; a subset of these correspond directly to the common SQL
"INSERT|UPDATE|DELETE" statements. In Routines.pod, these 11 updaters
were added as "sys.std.Core.Relation.\w+":
"assign_(|disjoint_)(insertion|union)",
"assign_(deletion|(|cmpl_)restriction)",
"assign_(intersection|(|semi)difference|semijoin)". In Relation.pod,
these 7 updaters were added as "sys.std.Relation.\w+":
"assign_exclusion",
"assign_(|static_)substitution(|_in_(restriction|semijoin))".
* (Routines_Catalog.pod) In a reversal of one aspect of release
0.19.0, brought back the then-removed "Cat.Order_reverse" function,
under the slightly updated name "sys.std.Core.Cat.Order_reverse".
* (Routines_Catalog.pod) Added an initial complement of 22 data
definition procedures, each of which is an abstraction for inserting or
deleting a tuple in a catalog relvar. These 22 procedures were added
as "sys.std.Core.Cat.\w+":
"(create|drop)_(depot_mount|subdepot|package)",
"(create|drop)_(depot|package)_(function|updater|procedure|type)". In
addition, the 1 procedure "alter_depot_mount_so_we_may_not_update" was
added in that namespace, which instead updates a catalog tuple.
* (Routines.pod) Added an initial complement of 7 generic standard I/O
system service routines, which should now round out provisioning Muldis
D to be computationally complete. The 7 system service routines were
added as "sys.std.Core.STDIO.\w+": "(read|write|error)_Text(|_line)",
"prompt_Text_line". These are mainly for implementing command-line
user interfaces and error diagnostics for programs, and just handle
Text; there are no bit string equivalents as yet.
* (Types_Catalog.pod) Fixed a few typos.
2008-07-29 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.43.0 is released on CPAN as
Muldis-D-0.43.0.tar.gz.
* New file versions are: D.pm 0.43.0. The other pre-existing versioned
files are unchanged.
* Savagely chopped the Live Talk version of the Muldis_D_PDAFP_200807
slideshow to remove all the content text, keeping just the section
headings, a handful of bullets, and all but one of the code samples.
There should be no doubt whatsoever now that the presenter isn't
reading the slides; also, this result is more like the actual Takahashi
format that the XUL software is designed for; also, it now should be
easier to fit into the allowed time. This was presented at OSCON on
July 23. Then the Stand Alone version had its end updated to format
like the rest of the SA slideshow. And so following this, this
2-version 2008 July slideshow is now frozen into the archives.
* The file archives/OSCON2008SessionProposal.txt was moved from the
Muldis Rosetta version control / distribution to the Muldis D one; also
there is now just one copy versus with 2 versions of Muldis Rosetta.
2008-07-21 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.42.0 is released on CPAN as
Muldis-D-0.42.0.tar.gz.
* New file versions are: D.pm 0.42.0. The other pre-existing versioned
files are unchanged.
* Edited and trimmed the slideshow "archives/Muldis_D_PDAFP_200807.xul"
substantially, removing about 30% of its size. The changes were
inspired largely by feedback from several sources on the version in
release 0.41.0. The cuts mainly were about removing "boring" parts
like introductives and less interesting or common features; also many
parts were edited to say the same thing in substantially fewer words;
all in all, this was just fat trimming and the result shouldn't lack
anything useful that was in the previous one. This new version would
barely fit in 45 minutes if read aloud, but it is in fact now intended
as the paper for download, so people not at a live talk based on this
can still get all the material. There was also some reordering, and a
bit of additions near the front to make it easier to know early what
the talk and the project is about.
* Forked said slideshow into a "_sa" (Stand Alone) and "_lt" (Live
Talk) version, the former being the version for viewing on its own, or
use as speaker's notes, and the latter for actual display during the
talk. The live version changes the quasi-sentences of the stand alone
to bullet points and less text. This was presented at PDXPug PGDay on
July 20th.
* Partly due to feedback gotten at the OSCON speakers' workshop on July
21, the talk will be redone again, using a different presentation tool,
and making the live version have very little content so it differs
greatly from what is spoken, this all in preparation for July 23.
2008-07-15 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.41.0 is released on CPAN as
Muldis-D-0.41.0.tar.gz.
* New file versions are: D.pm 0.41.0 and Basics.pod 0.27.1 and
HDMD_Perl_Tiny.pod 0.22.1. The other pre-existing versioned files are
unchanged.
* (Basics.pod, HDMD_Perl_Tiny.pod) Fixed typos.
* Rewrote the slideshow "archives/Muldis_D_PDAFP_200807.xul" so it has
more appropriate content, and is a better length. While this version
should be complete on talking about Muldis D, it still lacks anything
on Muldis Rosetta, which should end up about 10% of the size, except
that there are internal todo notes on this. And next I'll need to chop
down the size of the new version so it can be presented in about 45
minutes, for which I'll solicit advice. That cut version should be in
a near future subsequent release.
2008-07-08 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.40.0 is released on CPAN as
Muldis-D-0.40.0.tar.gz.
* New file versions are: D.pm 0.40.0. The other pre-existing versioned
files are unchanged.
* Added new file "archives/Muldis_D_PDAFP_200807.xul" which is the very
rough first draft of the slideshow for the 2008 July talk "Muldis D -
Portable Databases At Full Power". This talk is created for giving at
OSCON 2008, and it is also being given at several other events in 2008
July. Following a practice presentation on 2008 July 8th, which used
the (first half of) this exact file (except new postscript first
screen), it was decided to completely rewrite the slideshow with
different content. Meanwhile this version is now being released on
CPAN for posterity. The next CPAN release of Muldis D will not have
this version, rather its replacement. This talk is a XUL file and it
requires Mozilla Firefox to run (or you can read its text in a text
editor). Also added the 2 support files "archives/takahashi.(css|js)"
plus the file "archives/README".
2008-07-04 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.39.0 is released on CPAN as
Muldis-D-0.39.0.tar.gz.
* New file versions are: D.pm 0.39.0 and Types_Catalog.pod 0.33.0 and
Routines.pod and Array.pod 0.28.0 and Basics.pod 0.27.0 and Ordered.pod
and Relation.pod and Set.pod 0.26.0 and Tuple.pod and Bag.pod 0.25.0.
The other pre-existing versioned files are unchanged.
* (Types_Catalog.pod) Updated the catalog type 'DKMemRelAttrMap' so
its 'rel_name' attribute is now a 'DeclNameChain' rather than a 'Name'.
So now, relation-typed attributes participating in a common distributed
(unique) key no longer have to be direct siblings, but rather could be,
eg, cousins instead; that is, now members of a distributed key may be
spread out in different namespaces (within a common depot).
* (Basics.pod, Types_Catalog.pod) Added new routine kind
"virtual_attr_map" in the ROUTINES main section, so to formalize the
concept of a mapping function used to define virtual nonscalar
attributes in terms of a functional dependency on other attributes, in
general not 1:1. Added new catalog type 'VirtualAttrMapSet' which
embeds such a function and defines virtual attributes of a nonscalar
type which it is embedded into; also added 'NameDNCMap' which supports
the first addition. Updated the 'InnerNonscalarType' catalog type to
add a new 'virtual_attr_maps' attribute. Features provided by this
update include virtual relvars (views), and the easier ability to do
things like case-insensitive key constraints.
* (Types_Catalog.pod) Added 3 new catalog types ['ForeignKeySet',
'ForeignDistribKeySet', 'FKChildAttrParentAttrMap'], and added 2 new
attributes 'foreign_(|distrib_)keys' to the 'InnerNonscalarType' type.
These additions provide canonical abstraction syntax for
foreign/referential key constraints between relation-valued attributes
or their attributes etc of a nonscalar type; two versions exist, one
that targets a key of a single relation as the parent, and one that
targets a distributed key on multiple relations as the parent.
* (Types_Catalog.pod) Added 4 new quasi-scalar catalog types
'(Func|Proc|Type|OrdDetFunc)Ref' as an initial solution to the problem
that plain 'NameChain' don't actually work too well as values to
represent closures or higher order functions in the general case,
particularly when wanting to use an inner routine as a closure to pass
to another routine defined in some external context; these were added
in the new main pod section "TYPES FOR SPECIAL ENTITY REFERENCES".
Also added 4 new expression node catalog types,
'(Func|Proc|Type|OrdDetFunc)RefLitExprNodeSet', for selecting values of
the first 4 types. Also added 5 new attributes to the 'ExprNodeSet'
type that are of the 4 new node types.
* (Routines.pod, Ordered.pod, Tuple.pod, Relation.pod, Set.pod,
Array.pod, Bag.pod) Updated all routine parameters that conceptually
were closure-et-al-typed (each such parameter took the name of a
function or imperative routine or data type), so that their actual
types were the new '(Func|Proc|Type|OrdDetFunc)Ref' types rather than
the 'NameChain' type. Also updated all routine parameters that take a
set of argument values for closures so that the data type of said
parameters is 'QuasiTuple' rather than 'Tuple', which is more
appropriate in the general case.
2008-06-30 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.38.0 is released on CPAN as
Muldis-D-0.38.0.tar.gz.
* New file versions are: D.pm 0.38.0 and Types_Catalog.pod 0.32.0. The
other pre-existing versioned files are unchanged.
* (Types_Catalog.pod) Split up the catalog type 'ProcStmt' 3 ways into
the catalog types ['StmtNodeSet', 'CompoundStmtNodeSet',
'ProcInvoStmtNodeSet']; also updated the 'InnerProcBody' type to rename
its 'stmts' attribute to 'stmt' and retype that attribute from
'array_of.ProcStmt' to 'StmtNodeSet'. So now the main body of a
procedure has been restructured to be more like the main body of a
function, such that the procedure body is now a tree of statement nodes
rather than a flat sequence of statements; now each tree node is a code
block grouping its child nodes. This restructuring has resulted in 2
initial kinds of statement nodes; a compound statement node is a
sequence of other statements; a procedure invocation node invokes a
named procedural routine.
* (Types_Catalog.pod) Added new catalog type 'LeaveStmtNodeSet' which
represents an abnormal exit from a statement block or a return from a
procedure ('abnormal' meaning not running to the end). Also made
corresponding attribute addition to 'StmtNodeSet' type.
* (Types_Catalog.pod) Renamed the 2 catalog types ['IfThenExprMap',
'WhenThenExprMap'] to ['IfThenMap', 'WhenThenMap'] and generalized
their descriptions so they apply to both control flow statements as
well as control flow expressions. Also moved those into the "SIMPLE
GENERIC NONSCALAR TYPES" section from the "TYPES FOR DEFINING INNER
ROUTINE BODIES" section.
* (Types_Catalog.pod) Added 2 new catalog types ['IfElseStmtNodeSet',
'GivenWhenDefStmtNodeSet'] which (together with the aforementioned 2
renamed 'Map' types) define N-way if-else and given-when-default
control flow statement nodes. They are like the similarly named
expression node kinds but for being imperative. Also made
corresponding attribute additions to 'StmtNodeSet' type.
* (Types_Catalog.pod) Added new catalog type 'LoopStmtNodeSet' which
implements a generic looping block statement; the looping block is an
infinite loop save for exiting when an appropriate 'LeaveStmtNodeSet'
is invoked within it. Also added new catalog type 'IterateStmtNodeSet'
which will jump to the start of the next iteration of a current loop.
Also made corresponding attribute additions to 'StmtNodeSet' type.
2008-06-28 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.37.0 is released on CPAN as
Muldis-D-0.37.0.tar.gz.
* New file versions are: D.pm 0.37.0 and Types_Catalog.pod 0.31.0 and
Routines.pod 0.27.0. The other pre-existing versioned files are
unchanged.
* (Types_Catalog.pod) Renamed the catalog type 'InnerDomainType' to
'InnerUnionType' and added new catalog type 'InnerRestrType'; the
latter is now a more terse way to specify the common kind of type that
is a simple subset of a single other type, either a proper subtype or a
non-proper one that has a different default value. Also renamed the
'InnerDomTypeSet' type to 'InnerUniTypeSet' and added the new
'InnerRestrTypeSet' type. Also renamed the 'InnerNonScaTypeSet' to
lowercase the first 'S'. Also 'InnerTypeSet' now has 4 attributes.
Any other catalog types which had attributes of any of the above types
were also appropriately updated.
* (Types_Catalog.pod) Added 4 new catalog types ['IfElseExprNodeSet',
'IfThenExprMap', 'GivenWhenDefExprNodeSet', 'WhenThenExprMap'] which
collectively define N-way if-else and given-when-default control flow
expressions. This control flow functionality is implemented using
special catalog types rather than generically as routines because they
carry special short-circuit semantics such that some of their operands
are only conditionally evaluated (which isn't true with routines in
general), generally because some operands are determining whether we
even know it is legal to evaluate some other operands. Also added 2
attributes to the 'ExprNodeSet' catalog type, ['if_else_exprs',
'given_when_def_exprs'].
* (Routines.pod) Renamed or grouped the headings of a few pod
sections, added a few as well.
* (Routines.pod) Added new function 'sys.std.Core.Universal.assertion'
which is like 'treated' but that rather than a type name argument it
takes a boolean argument; it passes through the main value argument if
the boolean is true, and throws an exception otherwise. This function
exists to support arbitrary condition assertions in pure functions
potentially at runtime or compile time without the necessesity of
defining superfluous new types with type constraints.
* (Routines.pod) Added 3 new control-flow routines named
'sys.std.Core.Control.(func|upd|proc)_invo', each of which takes a
routine name as an argument and then invokes it with arguments given as
another argument. These are the fundamental routines over which other
routines that want to invoke a routine whose name or parameters they
might not know until runtime would do it, such as generic relational
restriction or the map or reduction operators or try_catch.
2008-06-24 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.36.0 is released on CPAN as
Muldis-D-0.36.0.tar.gz.
* New file versions are: D.pm 0.36.0 and Types_Catalog.pod 0.30.0 and
Blob.pod and Array.pod and Rational.pod 0.27.0 and Basics.pod and
Routines.pod and Integer.pod 0.26.0 and Ordered.pod and Text.pod and
Relation.pod and Set.pod 0.25.0 and Bag.pod 0.24.0 and Conventions.pod
0.3.0. The other pre-existing versioned files are unchanged.
* (Array.pod) Fixed 'limit_of_Array_from_wrap' so 2 of its parameters
are named 'ord_(func|assuming)' and not '(func|assuming)'.
* (Basics.pod, Types_Catalog.pod) Added support for routines to have
optional parameters in addition to non-optional parameters, rather than
just the latter kind; when no explicit argument is given to an optional
parameter, its value will default to the default value of its declared
type; for subject-to-update parameters, this also results in a
temporary variable. In Basics.pod, added a paragraph to the pod
section "ROUTINES" that introduces this feature. In Types_Catalog.pod,
added a new "opt_params" attribute to each of the 3 catalog types
"Cat.(Func|Upd|Proc)Head", which says which parameters are optional.
Also updated Basics.pod to say that the third "assuming" parameter of a
"order_determination" function is now optional.
* (Conventions.pod) Added new pod section "Defaults and Options" which
has suggestions concerning the use of optional parameters and default
values for types.
* (Types_Catalog.pod, Ordered.pod, Array.pod) Added new scalar catalog
type 'OrdDetFuncNameChain' which is the same as 'NameChain' but for
having the different default value of 'sys.std.Core.Scalar.order'.
Also updated every 'func' parameter of 'sys.std.Ordered.\w+' to be
declared of the new type rather than 'NameChain'. Likewise updated the
declared type of 'ord_func' of 'sys.std.Array.Array_from_attr'.
* (Routines.pod, Ordered.pod, Integer.pod, Blob.pod, Text.pod,
Relation.pod, Set.pod, Array.pod, Bag.pod, Rational.pod) Made some
routine parameters optional, which are listed here; the optional
parameters were marked in routine signatures by adding a '?' like in
Perl 6, an example being 'foo(Bool)?'. In Routines.pod: every
'possrep' of 'sys.std.Core.Scalar.\w+', 'assuming' of
'sys.std.Core.Scalar.order', every '\w*assuming' of
'sys.std.Core.Relation.\w+', '(try|catch)_(updating|assuming)' of
'sys.std.Core.Control.try_catch'. In Ordered.pod: every 'func' and
'assuming' of 'sys.std.Ordered.\w+', 'm(in|ax)_is_outside' of
'sys.std.Ordered.is_(in|out)side_range'. In (Integer|Rational).pod:
'exclude_m(in|ax)' of 'sys.std.(Integer|Rational).fetch_random'. In
(Blob|Text).pod: 'fixed_(start|end)' of
'sys.std.(Blob|Text).is(|_not)_substr'. In
(Relation|Set|Array|Bag).pod: every '\w*assuming' of
'sys.std.(Relation|Set|Array|Bag).\w+'. In Array.pod:
'ord_(func|assuming)' of 'sys.std.Array.Array_from_attr'.
* (Text.pod) Added new pod section "FUNCTIONS FOR TEXT NORMALIZATION"
and moved into it the 3 functions "case_folded_to_(upper|lower)" and
"whitespace_trimmed"; also added 2 new functions in that section named
"accents_stripped" and "ASCII". This function group in general is
about normalizing text such as to support operations like case or
accent or whitespace insensitive comparison or sorting; similarly they
are useful upon which to build an emulation of a naturally insensitive
language over the case et al sensitive Muldis D.
* (Text.pod) Added new pod section "FUNCTIONS FOR PATTERN MATCHING AND
TRANSLITERATION" with an initial complement of 2 operators
"is(|_not)_match_using_like" that implement the full generalization of
SQL's "(|NOT )LIKE" operators. Later on we need to add operators for
transliteration, and Perl regular expression matching, and so on.
2008-06-21 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.35.0 is released on CPAN as
Muldis-D-0.35.0.tar.gz.
* New file versions are: D.pm 0.35.0 and Blob.pod and Array.pod and
Rational.pod 0.26.0 and Basics.pod and Routines.pod and PTMD_Tiny.pod
and Integer.pod 0.25.0 and Ordered.pod and Tuple.pod and Relation.pod
and Set.pod 0.24.0 and HDMD_Perl_Tiny.pod 0.22.0 and Temporal.pod
0.8.1. The other pre-existing versioned files are unchanged.
* (Basics.pod) Added new "Type Safety" pod section under TYPE SYSTEM,
which says such things that Muldis D is type safe, it is hybrid
static/dynamic, some other things. Also it declares that Muldis D now
has a concept of "warnings" and some things that used to be fatal
errors are now by default warnings instead; mainly this concerns
fatalism concerning 'incompatible' declared types in contexts where the
values in question are valid for the contexts. Also updated some other
sections under TYPE SYSTEM, and a few other spots in the file. Also
added new term 'warn' to the NOTES ON TERMINOLOGY section, which is
related to but distinguished from 'fail'.
* (Routines.pod, Ordered.pod, Tuple.pod, Relation.pod, Set.pod,
Array.pod) Updated the documentation for several routines that stated
failure conditions so that some of those are now warning conditions
instead. The primary change here is that "is_identical" now will
always warn (and probably result in false) where it used to fail, and
there are now no conditions where it will fail; so now the system will
let you compare any value to any value regardless of the declared types
of their sources; but declared types will have an affect on whether
there is a warning or not, in case you want to be told when you compare
an integer to a string. Also, "assign" will now only fail if the value
to assign isn't of the declared type of the target; it will now warn
instead of fail if the declared type of the value isn't compatible. A
lot of other changes related to tuple or relation values versus
declared types, and various other fall-out from the is-identical
change.
* (Relation.pod, Set.pod) Updated the 'outer_join_with_defaults' and
'attr_or_default' functions so that each now has an extra
Cat.NameChain-typed argument that specifies the type to use the default
value of; the functions no longer use the declared type of some other
of their arguments to use the default of, since that is unreliable.
* (Routines.pod, Relation.pod, Blob.pod) Updated the 7 functions
['union', 'disjoint_union', 'intersection'; 'exclusion'; 'and', 'or',
'xor'] so that they now fail when given zero input elements rather than
result in an identity value; while such identities conceptually exist,
an empty input element list lacks the information to make one, so for
these functions the best general solution is to make the caller work
around the zero element limitation as it sees fit (such as adding an
identity value to the input list); adding an identity parameter instead
was rejected as that makes the most common use cases more verbose.
* (Relation.pod) Deleted the 2 functions ['universal', 'negation']
since they wouldn't have worked in the current forms; they depend on
knowing a declared type which isn't reliably obtainable without being
explicitly given in an extra parameter; moreover most universal
relations would be too large to handle or infinite. Also updated the
'empty' function description.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Fixed a bug in the grammar of
the 'radix' format for specifying a Rat literal; the bug was such that
one couldn't select a non-zero rational value between -1 and +1
exclusive; that is, one couldn't say something like "0.N".
* (PTMD_Tiny.pod) Refactored the grammar concerning integers and
rationals to factor out the 3 new tokens int_max_col_val, int_body,
pint_body. Affected older tokens were 'int', 'count', 'rat_\w+'.
* (Ordered.pod) Updated the 2 "is_(in|out)side_range" functions to
rename each of their 2 "m(in|ax)_is_inside" parameters to
"m(in|ax)_is_outside"; and now the min|max values are included in the
range to check against rather than being excluded.
* (Integer.pod, Rational.pod) Added 1 system service routine to each
file named "sys.std.(Integer|Rational).fetch_random", respectively,
which generates a random number using some implementation-defined
method, which may be anywhere from truly random to pseudo-random. The
routines take parameters to specify the domain the generated number
must be in, which consists of range endpoints for both routines, as
well as a maximum precision specifier for the rational one. In the
future, these routines may be replaced by more that give the user some
control over what algorithm is used to produce the random numbers, or
to specify a seed where applicable.
* (Temporal.pod) Made a few typo fixes in routine signatures.
2008-06-13 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.34.0 is released on CPAN as
Muldis-D-0.34.0.tar.gz.
* New file versions are: D.pm 0.34.0 and Temporal.pod 0.8.0. The other
pre-existing versioned files are unchanged.
* In summary, this release consists just of a rewrite of the Muldis D
Temporal Extension, which seems to improve the complement of data types
from before, and also adds a complement of operators, which there were
none of before. That said, the new version still appears to have some
serious issues which should be dealt with in the future. One problem
is the combinatorial explosion of types and routines, due to desire to
have a wall between different precisions. Another problem concerns
interaction of plain 'time' types and time zones, such as what
semantics their operators should have.
* (Temporal.pod) Rewrote the complement of temporal data types. In
summary, the previous 10 temporal scalar root types were replaced by 21
new temporal scalar root types; these new types all have a possrep each
that is formally defined, while the old types had no possreps defined.
For specifics: 2 'DurationOfDays(No|With)TZ' became 1 'DurationOfD', 2
'Duration(No|With)TZ' became 1 'DurationOfFS', 2 'Date(No|With)TZ'
became 1 'DateToD', 2 'DateTime(No|With)TZ' became 2
'DateToFS(|WithTZ)', 2 'Time(No|With)TZ' became 2 'TimeToFS(|WithTZ)',
4 'DurationOf(Y|M|I|S)' were added, 4 'DateTo(Y|M|I|S)' were added, 2
'DateTo(I|S)WithTZ' were added, 4 'TimeTo(I|S)(|WithTZ)' were added.
Also added 6 proper subtypes of 'Int' named ['NZInt', 'PInt(12|31)',
'UInt(23|59|62)'], and 1 proper subtype of 'Rat' named 'URatLT1', to
the Temporal Extension in order for the aforementioned new scalar root
types to be implemented over.
* (Temporal.pod) Rewrote the file's DESCRIPTION pod to bring it up to
date with current changes and plans, and it is now much larger. The
DESCRIPTION notes that the Muldis D Temporal Extension is not meant to
be a complete solution for temporal data, but rather is just meant to
be good enough to support porting databases from SQL to Muldis D
without users having to define for themselves the temporal types that
SQL bundles. For more complete temporal handling, users should either
write their own custom solutions as UDTs et al or look to third-party
Muldis D extensions.
* (Temporal.pod) Added initial complement of 63 temporal math
functions and 30 system services for getting the current date. There
are 18 functions named
"sys.std.Temporal.DurationOf(Y|M|D|I|S|FS).(abs|sum|difference)", and
18 functions named
"sys.std.Temporal.DateTo(Y|M|D|I|S|FS).(difference|later|earlier)", and
9 functions named
"sys.std.Temporal.DateTo(I|S|FS)WithTZ.(difference|later|earlier)", and
18 functions named
"sys.std.Temporal.TimeTo(I|S|FS)(|WithTZ).(difference|later|earlier)".
There are 12 system services named
"sys.std.Temporal.DateTo(Y|M|D|I|S|FS).fetch_current_date_(utc|local)",
and 6 system services named
"sys.std.Temporal.DateTo(I|S|FS)WithTZ.fetch_current_date_(utc|local)",
and 12 system services named
"sys.std.Temporal.TimeTo(I|S|FS)(|WithTZ).fetch_current_time_(utc|local
)".
2008-06-04 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.33.0 is released on CPAN as
Muldis-D-0.33.0.tar.gz.
* New file versions are: D.pm 0.33.0 and Types_Catalog.pod 0.29.0 and
Routines.pod 0.24.2 and Basics.pod 0.24.0. The other pre-existing
versioned files are unchanged.
* (Basics.pod) Added a short paragraph under TYPE SYSTEM that
clarifies Muldis D does subtyping using "specialization by constraint"
(not "by extension"), using those very terms.
* (Basics.pod) Rewrote a portion of the "Scalar Types" subsection of
TYPE SYSTEM to bring it up to date concerning the nature of possreps,
possrep maps, and particularly of the nature of what operators are or
aren't built-in to types, and what are automatically system-defined.
Also made a few other small changes in Basics or TYPE SYSTEM.
* (Basics.pod, Types_Catalog.pod) Specified that all possrep names of
all scalar types in a common hierarchy (under the same root type) must
have distinct names regardless of whether they share values, so to keep
diamond inheritence more simple and deterministic.
* (Types_Catalog.pod) Added initial complement of catalog types that
define controls for mounting and unmounting depots, in the new main pod
section "TYPES FOR DEFINING MOUNT CONTROLS"; this consists of the 2 new
types "Cat.MountControl(Cat|Set)". This fills in one of the arguably
very few remaining gaps in essential language functionality. Some
standard customizations per depot mount include readonly vs updateable,
temporary or not, create on mount or not; most customizations are left
to implementation-specific 'details' though, such as file names or
authentication credentials.
* (Basics.pod, Types_Catalog.pod, Routines.pod) Added new routine kind
"type_default" in the ROUTINES main section, so to formalize the
concept of a zero-parameter function that always results in a certain
value of a type. Updated documentation for the 'Universal.default'
function, and for catalog type attributes of that kind of function, to
use that name.
* (Basics.pod, Types_Catalog.pod) Added new routine kind "possrep_map"
in the ROUTINES main section, so to formalize the concept of a 1:1
mapping function used in scalar type definitions; updated the relevant
type-defining catalog type docs accordingly.
* (Types_Catalog.pod) Updated the 'Cat.PossrepSet' type so that its
'constraint' attribute may be less restricting than otherwise when
there are multiple possreps in the same scalar (|sub)type; the total
constraint on a type is the 'and'-ing of all of its possrep
constraints, so each individual one in general only needs to restrict
enough that inter-possrep map funcs can work, and the other constraints
can be applied too. (This detail is subject to revision.) Also
updated all of the inner types to specify that their '*constraint'
attributes default to be unconditionally true, unlike the inner-func
default of unconditionally false.
* (Types_Catalog.pod) Updated the 'Cat.InnerDomainType' type so that
it must have at least 1 source type rather than at least none, and
updated the handling of filter types so they default to union rather
than intersect; also renamed the is_filter_union attribute to
is_filter_intersection; also clarified that it is invalid to declare a
domain type that is an alias of 'Empty' due to needing a default value.
* (Basics.pod) In a reversal of one aspect of release 0.9.0, updated
ROUTINES to bring back the distinct 'state_constraint' routine kind,
and rewrote it so it is now the same as a 'type_constraint', being a
pure function with 1 parameter rather than a routine that can see
globals. Also updated the definitions of 'type_constraint' and
'transition_constraint' to conform to recent catalog formalizations;
the first one now always just takes the single 'topic' parameter. And
all constraints must not unconditionally result in Bool:false. Note
that the catalog still doesn't define how to apply state or transition
constraints to variables; such an update is pending.
* (Types_Catalog.pod) Added new type 'Cat.ConstraintSet' which defines
a set of named generalized constraints (type or state or transition
etc; technically its a named set of InnerFuncBody). Updated the 2
types 'Cat.Inner(Nonscalar|Domain)Type' to pluralize the names of their
generic constraint attributes, and those attributes' types are now the
ConstraintSet type rather than the InnerFuncBody type. The net result
of these changes is that type constraints, on particularly
tuple|relation|database types, can now be split into N named pieces,
which should make them easier to write when complicated, and make
debugging or input validation easier since the name of each smaller
constraint would be in the exception resulting from its failure.
* (Types_Catalog.pod) Added support for an abstraction for defining
distributed (unique) keys over relation-valued attributes of a
tuple/database type. Added 3 new types Cat.DistribKeySet,
Cat.DKMemRelAttrMap, Cat.DKRelAttrKeyAttrMap which define distributed
keys, and added 1 new DistribKeySet-typed attribute named
'distrib_keys' to the 'Cat.InnerNonscalarType' type.
2008-06-04 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.32.0 is released on CPAN as
Muldis-D-0.32.0.tar.gz.
* Renamed Sequence.pod to Array.pod; the entities it declares have all
been renamed to "sys.std.Array.\w+" from "sys.std.Sequence.\w+". Any
references to these in other files [D.pm, Core.pod, Relation.pod, the
README file] were updated accordingly.
* New file versions are: D.pm 0.32.0 and Types_Catalog.pod 0.28.0 and
Types.pod and Blob.pod and Array.pod 0.25.0 and Routines.pod 0.24.1 and
PTMD_Tiny.pod and Text.pod 0.24.0 and Relation.pod 0.23.1 and
Basics.pod 0.23.0 and Core.pod 0.21.2 and HDMD_Perl_Tiny.pod 0.21.0.
The other pre-existing versioned files are unchanged.
* (Basics.pod, Routines.pod) Made a few typo fixes.
* (Basics.pod) In the NOTES ON TERMINOLOGY main pod section, updated
the 'sequence' entry to add 'array' as a synonym for it. Rather than
avoiding the use of 'array' altogether given its more broad meaning in
wider contexts like any indexed list, including associative arrays, we
now simply say that those other meanings aren't used in this
documentation, and only the meaning of an ordered collection applies.
Also added a related item 'sequence generator' to the above entry, and
specified that only the longer term refers to a sequence generator, and
that 'sequence' by itself does not.
* (Types.pod) Renamed the 2 core types '(|Quasi)Seq' to
'(|Quasi)Array'. The change to use Array rather than Seq was done for
3 main reasons, the first of which was to make the type name more
visually distinctive from the Set type; the second reason was because
the overwhelming majority of other languages used the name Array, and
its not like I was using the term for anything else, and its not like
my reason for avoiding it before was particularly good; the third
reason was to reduce confusion about the type name referring to a
sequence generator, as SQL users may think. As a fourth reason, this
change had the side-effect that the associated language extension and
its entities now have shorter names; Array from Sequence; and the
extension name Sequence is now freed up for possible use related to a
sequence generator.
* (Types_Catalog.pod) Updated the 2 types '(|Decl)NameChain' so that
their 'seq' possrep is now named 'array'.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Updated the literal syntax for
'(|Quasi)Array' values to use the type's new name, and updated the
literal syntax for '(|Decl)NameChain' values so that their new possrep
name is used.
* (Basics.pod) In the "Referencing Data Types" pod section under
ENTITY NAMES, updated the spelling for '(|quasi_)seq_of' to be
'(|quasi_)array_of', in accordance with the type name changes.
* (Array.pod, Types_Catalog.pod, Blob.pod, Text.pod) Updated any
routine signatures or nonscalar type definitions that used
'Seq'|'seq_of' to use 'Array'|'array_of' instead. In Array.pod, also
renamed the 2 'is_(|not_)subseq' functions to 'is_(|not_)subarray'.
* (Routines.pod, Relation.pod) Updated any references on 'Seq' in the
documentation to 'Array'; these are only description pod updates.
* (Array.pod) Removed 'last_index' as it seems to be less useful than
previously thought; it isn't really a short-hand for 'cardinality'
since to make it work also with empty sequences, it would need to
result in a Maybe or be wrapped in tests.
2008-05-20 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.31.0 is released on CPAN as
Muldis-D-0.31.0.tar.gz.
* Split apart Nonscalar.pod 2 ways into Tuple.pod and Relation.pod; the
first file got the 4 "sys.std.Nonscalar.Tuple.\w+" named functions
(grouped in 1 pod section), and the second file got all the remaining,
27 "sys.std.Nonscalar.Relation.\w+" named functions (grouped in 4 pod
sections); following the split, the functions were renamed to
"sys.std.Tuple.\w+" and "sys.std.Relation.\w+", respectively. Any
references to these in other files [D.pm, Core.pod, the README file]
were updated accordingly.
* New file versions are: D.pm 0.31.0 and Types_Catalog.pod 0.27.0 and
Rational.pod 0.25.0 and Types.pod and Routines.pod and Sequence.pod
0.24.0 and PTMD_Tiny.pod and Ordered.pod and Tuple.pod and Relation.pod
0.23.0 and Basics.pod 0.22.0 and Core.pod 0.21.1 and HDMD_Perl_Tiny.pod
0.20.0. The other pre-existing versioned files are unchanged.
* (Basics.pod, Types.pod) Fixed a few fossils.
* (Types_Catalog.pod) Renamed the main pod sections "TYPES FOR
DEFINING ENTITY NAMES AND COMMENTS" and "SIMPLE GENERIC CATALOG
COLLECTION TYPES" to "SIMPLE GENERIC (|NON)SCALAR TYPES", respectively.
* (Routines.pod) Added new "SYSTEM-DEFINED GENERIC SCALAR-CONCERNING
FUNCTIONS" main pod section, along with a complete complement of
generic scalar possrep attribute extraction and updating functions.
These 7 "sys.std.Core.Scalar.\w+" functions were added, which take
advantage of the fact that a scalar possrep looks just like a tuple:
'(|update_)attr', 'multi_update', '(|cmpl_)projection',
'Tuple_from_Scalar', 'Scalar_from_Tuple'.
* (Rational.pod) Removed the now-redundant (with 'Scalar.\w+') 7
rational numeric specific value selection and possrep attribute
extraction functions: 'Rat_from_Int_(pair|triple)', 'numerator',
'denominator', 'mantissa', 'radix', 'exponent'.
* (Basics.pod) Added new "Ordered Types" pod section under the TYPE
SYSTEM main section. It outlines the system-defined support for
order-sensitive operators and related best practices. Values of any
type can be explicitly sorted, but only scalar root types can have a
default sorting function defined for them. Currently, only functions
for total ordering have privileged support, but partial ordering
functions can be user-defined over such.
* (Basics.pod) Added new routine kind "order_determination" in the
ROUTINES main section, so that the concept of a "system-compatible
fundamental order-determination function" can now be referred to by a
terse name in the rest of the documentation.
* (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) In a reversal
of one aspect of release 0.19.0, brought back the then-removed
Cat.Order enumerated scalar type, but enhanced to have 2 possreps
rather than none (one over 'Name', one over 'Int'); also brought back
the literal syntax specific to this type in both Tiny dialects, but
sans any 'Cat.' prefix; also both dialects now provide for direct
analogies to both possreps.
* (Types_Catalog.pod, Routines.pod) Updated the 'Cat.InnerScalarType'
type to add a 7th attribute named 'order' which defines an optional
type-default total ordering function, which can only be defined with a
root type. Added generic scalar function 'sys.std.Core.Scalar.order'
which externalizes this function, and it is what other order-sensitive
operators can wrap when dealing with values of such scalar types.
* (Types.pod, Types_Catalog.pod, Rational.pod) Updated the
descriptions of the 10 types [Bool, Int, Blob, Text, Cat.Name,
Cat.NameChain, Cat.DeclNameChain, Cat.Comment, Cat.Order, Rat] to
explicitly declare that each one has a type-default ordering algorithm,
and to describe what that algorithm is. Also stated that the
RatRoundMeth type does *not* have a default ordering. (Still TODO is
to address the temporal and spatial types in one of these manners.)
* (Ordered.pod) Updated all of this language extension's
"order_determination"-wrapping functions to have the 2 extra parameters
"func" and "assuming", so that they can be customized as to what
fundamental function they wrap, whether one defined with the comparand
types or otherwise. Also added the function
'sys.std.Ordered.reverse_order'. Also, 'min' and 'max' no longer
result in an identity value with zero topic elements.
* (Relation.pod) Added new main pod section "SYSTEM-DEFINED RELATIONAL
RANKING AND QUOTA FUNCTIONS" with an initial complement of the 2
"sys.std.Relation.(rank|limit)" generic relational operators. The
"rank" function will extend the topic relation with an integer column
with the tuples ranked 0..N, that order determined by an
"order_determination"-function argument that it wraps; its
functionality is essentially SQL's "RANK" but the ordering is only
total, so no dense / not dense distinction. This "rank" function
provides the basis of both arbitrary quota queries as well as making
lists sorted. The "limit" function provides a specific kind of quota
query, in doing a restriction on the topic relation to a consecutive
range of tuples ranked as per "rank"; its functionality is like SQL's
"ORDER BY" plus "LIMIT" but the result is not a sequence.
* (Sequence.pod) Added the 2
"sys.std.Sequence.(|limit_of_)Seq_from_wrap" functions, which are
essentially the same as the above rank|limit but that the result is a
sequence rather than a generic relation. Prefer the sequence versions
when immediately returning the sorted query results, versus prefer the
rank|limit versions when using their results as a subquery in a larger
relational query. Also added "Seq_from_attr", which together with
"Seq_from_wrap" are analogies to similar Set and Bag functions. Also
added the 2 functions "last_index" and "slice".
* (Routines.pod) Removed the empty main pod section "SYSTEM-DEFINED
CORE CATALOG FUNCTIONS"; catalog-specific routines will instead go in a
new Core/Routines_Catalog.pod file when they come to be.
2008-05-12 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.30.0 is released on CPAN as
Muldis-D-0.30.0.tar.gz.
* New file versions are: D.pm 0.30.0 and Types_Catalog.pod 0.26.0 and
Integer.pod and Blob.pod and Rational.pod 0.24.0 and Types.pod 0.23.1
and PTMD_Tiny.pod 0.22.0 and HDMD_Perl_Tiny.pod 0.19.0 and
Conventions.pod 0.2.0. The other pre-existing versioned files are
unchanged.
* (Types.pod, Types_Catalog.pod) Fixed a few fossils.
* (Types_Catalog.pod) Refactored the catalog types for defining outer
data types. The oft-repeated attribute triple
"inner_(sca|non_sca|dom)_types" was factored out into the new tuple
(database) type Cat.InnerTypeSet, and a single "inner_types" attribute
of that type is now used in the outer routine and type defining types
rather than the triple. The 3 "Cat.(Scalar|Nonscalar|Domain)Type"
types were combined into the 1 "Cat.Type" type; now an outer type must
have at least 1 inner type, which defines the outer type, and that
inner type has the empty string for its name; this arrangement is akin
to an expression node hierarchy. Along with that, the 9
"Cat.(Sys|Dep|Pkg)(Sca|NonSca|Dom)TypeSet" types were combined into the
3 "Cat.(Sys|Dep|Pkg)TypeSet" types, and the corresponding 3 attributes
in each of "Cat.(System|Depot|Package)" were consolidated into 1
attribute for each.
* (Rational.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Renamed the
rational extension enumerated type "E_RM"/"Cat.E_RM" to just
"RatRoundMeth", and also updated its literal syntax in both Tiny
dialects likewise.
* (Rational.pod) Updated the "RatRoundMeth" type so that it explicitly
has a possrep that wraps the Cat.Name type, rather than implicitly
having no possreps.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Abbreviated the literal syntax
for scalar catalog types in both Tiny dialects so that the literals no
longer have a leading "Cat."; this affects the 4 types: Name,
NameChain, DeclNameChain, Comment; but with Name it only affects the
documentation since its literals had no 'Name' prefix to begin with.
* (Integer.pod, Blob.pod, Rational.pod) Updated the documentation so
that any types declared by these files which were referred to with a
"Cat." prefix now aren't; the affected types were "RatRoundRule" and
several "PInt\d\w+".
* (Conventions.pod) Removed the suggestion about enumerated types
being named like E_FOO; for one thing, no system-defined enums do that
anymore; also that format may be too terse for general practice.
2008-05-11 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.29.0 is released on CPAN as
Muldis-D-0.29.0.tar.gz.
* New file versions are: D.pm 0.29.0 and Types_Catalog.pod 0.25.0 and
Types.pod and Routines.pod and Integer.pod and Blob.pod and Text.pod
and Set.pod and Sequence.pod and Bag.pod and Rational.pod 0.23.0 and
Nonscalar.pod 0.22.0 and Basics.pod and PTMD_Tiny.pod 0.21.0 and
HDMD_Perl_Tiny.pod 0.18.0. The other pre-existing versioned files are
unchanged.
* (Basics.pod) Added new "User Namespace Correspondence" pod section
under ENTITY NAMES. It says how the namespaces *.lib and *.data
inter-relate, for example when they need to have corresponding sections
and when they need to have non-conflicting ones. Also, when a depot
has no subdepots or packages, then its "dep.data" is "just a database".
* (Basics.pod) Added new "Referencing Data Types" pod section under
ENTITY NAMES. It specifies a couple new language features, the first
of which lets you directly reference types that were baked into the
external interfaces of other entities like variables or routines, as if
they were normal explicitly declared types; also you can simply take
the corresponding tuple type for a relation type or vice-versa; the
second feature is that you can tersely declare simple collection types
inline, such as sets or sequences of Foo, saving the language and users
from a proliferation of explicitly declared simple (|quasi-)nonscalar
types like "MaybeOfInt" or "SeqOfText".
* (Types.pod) Removed the 6 explicitly declared tuple type factories
"(|Quasi)(Set|Seq|Bag)Elem", which are now superfluous as you should
now be able to use the "tuple_from" syntax on the
"(|Quasi)(Set|Seq|Bag)" type factories instead, if you need them.
* (Types.pod, Types_Catalog.pod, Integer.pod, Blob.pod, Text.pod,
Rational.pod) Removed the 38 explicitly declared 'Of' types which are
now superfluous: 24
"(Set|Maybe|Seq|Bag)Of(Bool|Int|UInt|Blob|Text|Rat)", 4
"(Set|Bag)Of(Tuple|Relation)", SetOfBag, MaybeOfTuple, SeqOfSeq, 2
"QuasiSetOf(Tuple|Relation)", SeqOfProcStmt, 4
"SetOf(Name|NameExprMap|SetOfName|NameChain)".
* (Types_Catalog.pod, Routines.pod, Integer.pod, Blob.pod, Text.pod,
Nonscalar.pod, Set.pod, Sequence.pod, Bag.pod, Rational.pod) Updated
all references to the aforementioned deleted 'Of' types, in type
attributes and routine signatures, to refer to the implicitly generated
'_of' versions instead. In Types_Catalog.pod, this also means that the
whole SYSTEM-DEFINED CORE QUASI-CATALOG PARAMETERIZED TYPES pod section
was eliminated.
* (Types.pod) Updated descriptions of the Database and Single types.
* (Types_Catalog.pod) Updated the 4
"Cat.(System|Federation|Depot|Package)" types to ensure that they
actually are "Database" types and not "just Tuple" types, since each
"cat" variable is supposed to be a valid "database". The only change
for each of the 4 types was to convert type of its "comment" attribute
from "Cat.Comment" (a scalar) to "single_of.Cat.Comment" (a relation);
the latter type was also added under the misc collection types section.
Also clarified that the "Cat.ExprNodeSet" type qualifies as a db type.
* (Types_Catalog.pod) Updated the 4 "Cat.Sys(Nsp|Func|Upd|Proc)Set"
types to flesh out the definition of their 'parent' attributes (which
had been left 'TODO'), and expanded the description of the "namespaces"
attribute of the "Cat.System" type.
* (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Refactored
the catalog types for defining data types. Previously, there was just
the single "Cat.Type" main type, plus 2 supporting enumerated types,
that handled all of special types, root scalar and nonscalar types,
domain types and union etc types. Now "Cat.Type" has been replaced
with mainly these 9 types: Cat.(|Inner)(Scalar|Nonscalar|Domain)Type,
Cat.Possrep(|Map)Set, Cat.KeySet; they handle all of the aforementioned
but for special types. There are 3 main type definition methods for
user-defined types, each of which is represented by an outer/inner
pair; the inners do all the work and outers are just wrappers for those
to make them explicit depot etc entities; multiple inners can be in an
outer, all but one playing support to the one, and inner types also can
be embedded in outer routines. With Cat.Type gone, the 2 enumerated
types Cat.E_TK and Cat.E_TDM were no longer useful and were eliminated;
along with their types, the special literal syntax for Cat.E_TK and
Cat.E_TDM was eliminated from the 2 Tiny dialects. Added the 9
Cat.(Sys|Dep|Pkg)(Sca|NonSca|Dom)TypeSet types and updated the
Cat.(System|Depot|Package) types to each have 3 corresponding
attributes, rather than each having a placeholder 'types' attribute.
Added the 3 Cat.Inner(Sca|NonSca|Dom)TypeSet types and updated the
Cat.(Func|Upd|Proc)Body types to each have 3 corresponding attributes,
rather than each having a placeholder 'inner_types' attribute; the 3
new outer type types each have the 3 corresponding attributes also.
Also added the 2 Cat.Sys(Spec|ScaNPR)TypeSet types and updated the
Sys.System type to have 2 corresponding attributes; these list the
special system-defined types of the kinds that users can't make.
* (Types_Catalog.pod) Added 2 catalog types for defining dbvars, both
of the catalog and user data variety: Cat.DbVar, Cat.SysCatSet. Updated
the catalog types Cat.(System|Depot|Package) to have a 'catalog' or
'data' attribute each rather than a placeholder. With this, all the
explicit TODO placeholders in Types_Catalog.pod are now gone.
* (Types_Catalog.pod) The placeholder catalog type Cat.Exception was
not addressed yet, and for now has been removed; it will come back
later; so the whole OLD TYPE DEFINITIONS TO REWRITE OR REPLACE pod
section was eliminated.
* (PTMD_Tiny.pod) The statement terminator semicolon no longer exists;
it was never needed to help parsing and its presence would probably
have confused people. Also added whitespace allowance between main
parts of rational literals.
* (PTMD_Tiny.pod) Added DESCRIPTION paragraph to point out that the
PTMD_Tiny dialect is designed for a single-pass parser or lexer, and so
it should be possible to parse such code simply and with little RAM;
also a paragraph about the flexibility programmers have for writing
code in the dialect, such as matters of whitespace.
2008-05-09 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.28.1 is released on CPAN as
Muldis-D-0.28.1.tar.gz.
* New file versions are: D.pm 0.28.1 and Types_Catalog.pod 0.24.2 and
Types.pod and Routines.pod and Ordered.pod and Integer.pod and Blob.pod
and Text.pod and Set.pod and Sequence.pod and Bag.pod and Rational.pod
0.22.1 and Nonscalar.pod 0.21.1 and Basics.pod 0.20.2 and PTMD_Tiny.pod
0.20.1 and HDMD_Perl_Tiny.pod 0.17.1 and Temporal.pod and Spatial.pod
0.7.1. The other pre-existing versioned files are unchanged.
* Completed the system entity renaming that began in release 0.27.0,
such that all fully-qualified references to types and routines in the
'sys.[A-Z]\w+' namespace have been renamed into the 'sys.std.[A-Z]\w+'
namespace. This was the only change made for release 0.28.1. To be
specific, the usage of 'sys.std' was already official in 0.27.0, and it
was just that most documentation was out of date until now.
2008-05-01 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.28.0 is released on CPAN as
Muldis-D-0.28.0.tar.gz.
* New file versions are: D.pm 0.28.0 and Types_Catalog.pod 0.24.1 and
Basics.pod 0.20.1 and PTMD_Tiny.pod 0.20.0 and HDMD_Perl_Tiny.pod
0.17.0. The other pre-existing versioned files are unchanged.
* (PTMD_Tiny.pod) Seq literals now use square brackets as list
delimiters rather than curly braces like most literals. It was decided
to standardize on using square brackets to delimit the few lists where
the order of elements in the literal is significant, while leaving the
curly braces for the majority lists where the order is not significant.
* (PTMD_Tiny.pod) All the separator and list delimiter tokens (that
are outside character string literals) now allow whitespace around
them, which can help you wrap long lines.
* (PTMD_Tiny.pod) Character string literals may now be divided into
1..N consecutive character string literal segments which are separated
by the (whitespace delimited) segment stitching character '~' (tilde);
this can help you wrap long character strings into multiple lines.
Likewise, blob literals can now be segmented using the same token. Now
we could have tried likewise with numeric literals too, but decided not
for simplicity, as the odds of that being used are next to none. Also
the flat formats for name chains can not be segmented; if you have one
that long, then use the sequence format for name chains instead.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Added another format for generic
relation literals that is more compact than the other main form due to
only stating attribute names once rather than repeating them per tuple;
the trade-off is that attribute values per tuple and their names are
now mapped by ordinal position in the literal so attribute order is not
immaterial; mutual order of whole tuples still is immaterial though.
* (Basics.pod, Types_Catalog.pod, PTMD_Tiny.pod) Fixed a few fossils.
2008-04-27 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.27.0 is released on CPAN as
Muldis-D-0.27.0.tar.gz.
* Removed the very incomplete file Hierarchical.pod, as it has become
more superfluous given the other Tiny dialects becoming more terse and
better for regular use. Not that other dialects can't be introduced
later, but they aren't as necessary now.
* New file versions are: D.pm 0.27.0 and Types_Catalog.pod 0.24.0 and
Basics.pod 0.20.0 and PTMD_Tiny.pod 0.19.0 and HDMD_Perl_Tiny.pod
0.16.0. The other pre-existing versioned files are unchanged.
* (D.pm, Basics.pod) In the ENTITY NAMES section of Basics.pod,
refactored the builtins namespaces to unify them under 'sys'; so what
used to be ['cat','sys','imp'] are now ['sys.cat','sys.std','sys.imp']
respectively. The VERSIONING section of D.pm had a corresponding
update. However, all the standard Muldis D routine and type
definitions or references in the Core/* and Ext/* and Dialect/* etc
files were *not* updated yet to the new naming scheme; those
documentation files will be updated piecemeal instead when they already
need to be updated for some other reason, especially for a related
global change; meanwhile, though most pod doesn't show it, the new
'sys.std' names are the actual official ones. Also, 'mnt' was split
into itself and 'mnt.cat', the latter being where the system catalog
for controlling depot mounts actually now is.
* (Basics.pod) In the ENTITY NAMES section, public-invokable types
and routines no longer have to be confined in packages, but can exist
directly in a depot or subdepot instead.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Added generic literal syntax for
selecting a value of any scalar or quasi-scalar type which has at least
1 possrep. The syntax is similar to a tuple literal, but rather than
being "Tuple:{ <attr names and values> }" it is "Scalar:<type
name>:<possrep name>:{ <possrep attr names and values> }". This
feature fills in a useability hole where previously it wasn't possible
to have literals of most scalar types in a bootloader, and such values
required the writing of a whole (temporary) routine to generate them.
* (PTMD_Tiny.pod) Updated the literal syntax for a Cat.NameChain so
its 'seq' representation now has square brackets around the name parts.
* (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Refactored
the catalog types for defining value expressions and routine
statements. Routine parameters and variables are now invokable
directly in expressions and statements, and are no longer invokable by
way of 'param' or 'var' etc expression nodes. Expression nodes and
parameters and variables are now invoked using Cat.NameChain rather
than Cat.Name (the implementing change was in Cat.NameExprMap), which
allows you both to access their attributes with minimal syntax, but
also normalizes the syntax for local and global variable access. The 2
types Cat.ProcStmtArg(|Set) were eliminated since, following the above
changes, Cat.NameExprMap could be used instead for defining procedure
statement arguments; then the Cat.E_PSAK enumerated type had no more
uses, and was eliminated. The 2 types Cat.(|Multi)UpdStmt were merged
into the 1 type Cat.MultiUpdStmt, which otherwise is essentially the
same as the old version. The 3 types Cat.Expr(Node|Set|Tree) were
refactored into the 6 types
Cat.(|(Sca|ScaPR|Tup|Rel)Lit|FuncInvo)ExprNodeSet; the first of those
is a tuple with 5 attributes, one each of the other 5 of those, which
are relations; so then an inner routine that used to have a
Cat.Expr(Set|Tree) attribute now has a Cat.ExprNodeSet attribute
instead; then the Cat.E_ENK enumerated type had no more uses, and was
eliminated. With the previous changes, code for expressions or
statements no longer has any inapplicable attributes, save relations
allowed to be empty. Along with their types, the special literal
syntax for Cat.E_ENK and Cat.E_PSAK was eliminated from the 2 Tiny
dialects.
* (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Added new
scalar type Cat.DeclNameChain, as well as its own literal syntax in
both Tiny dialects. This type is the same as Cat.NameChain except that
it allows 0..N name parts rather than 2..N, and its flat possrep also
has periods before and after the parts rather than just between them.
This type was added for use when declaring subdepots, depot entities.
* (Types_Catalog.pod) Added a set of 4 top-level catalog types which
are the types of the Muldis D catalog dbvars: Cat.System (for
'sys.cat'), Cat.Federation (for 'fed.cat'), Cat.Depot (for 'dep.cat'
and 'sdp.cat'), Cat.Package (for 'pkg.cat'). Added a set of 2 catalog
types which define nodes in N-depth namespace hierarchies for
organizing entities within a catalog: Cat.SysNspSet (hierarchies for
system-defined entities), Cat.SubdepotSet (hierarchies for user-defined
entities, for example SQL 'schema'); these 2 only declare that
namespaces exist, not what entities are in them. Added a set of 11
catalog types which specify/embed the definitions of entities in
catalog dbvars: Cat.DepotMountSet (what depot mounts are in a mount
federation), Cat.PackageSet (what packages are in a depot),
Cat.Sys(Func|Upd|Proc)Set (what system-defined routines there are),
Cat.(Dep|Pkg)(Func|Upd|Proc)Set (what user-defined routines there are,
directly in a depot or in a package of a depot, respectively); for the
system-defined routines, only the routine headings/interfaces are
specified, and for user-defined ones, both those and the
bodies/implementations are specified.
* (Types_Catalog.pod) Refactored the catalog types for defining
main|outer and inner routines, so that routine headings and bodies are
now separate from each other, and routine declared names are now
external to both parts; that is, a routine's name, if it has one, is
supplied by whatever other type embeds the otherwise anonymous routine
definition. The 11 types Cat.(|Inner)(Func|Updater|Proc) and
Cat.Inner(Func|Updater)(Set|Tree) and Cat.InnerProcTree were refactored
into the 12 types Cat.(Func|Upd|Proc)(Head|Body) and
Cat.Inner(Func|Upd|Proc)(Body|Set). Following this refactoring plus
the previous change item, the 'name' attribute for named functions is
directly in each of the 12 Cat.(Sys|Dep|Pkg|Inner)(Func|Upd|Proc)Set
types; all 12 have a 'head' attribute and all but the Sys have a 'body'
attribute, those embedding appropriate Head and Body types, the 3
together completely defining the routine. Both outer and inner
routines of the same kind use the same Head types, but have their own
Body types. Another change this refactoring brought is that an outer
routine no longer requires an inner routine to define its own
interface; now an outer routine body embeds its implementation detail
(still an inner routine Body) directly, rather than it being a list
item in an inner routines list whose name is the empty string;
therefore, outer routines no longer need to have inner routines at all
unless they do certain things.
* (Types_Catalog.pod) Despite the widescale refactoring, these 10
catalog types transitioned from the previous to the current design
while retaining their names and purpose, and also all or most of their
own design details: Cat.Name, Cat.NameChain, Cat.Comment,
Cat.SeqOfProcStmt, Cat.ProcStmt, Cat.NameTypeMap, NameExprMap,
AttrRenameMap, SetOfName, Cat.SetOfNameExprMap. Also some minor typo
fixes with a few of the 9 QuasiCat type docs, but the whole block was
left alone and still fits in fine.
* (Types_Catalog.pod) The following 6 catalog types were not addressed
yet and still need to be rewritten/refactored: Cat.E_TK, Cat.E_TDM,
Cat.Type, Cat.Exception, Cat.SetOfSetOfName, Cat.SetOfNameChain. More
generally speaking, the catalog types for defining data types (and
databases) still need to be rewritten, or actually they mostly need to
be written in the first place. Hopefully by the next Muldis D release.
* (Types_Catalog.pod) In the process of the other changes, the 3
largest main documentation sections, "SYSTEM-DEFINED CORE CATALOG (
SCALAR | TUPLE | RELATION ) DATA TYPES", were reorganized into the 10
main documentation sections "TYPES FOR DEFINING ( ENTITY NAMES AND
COMMENTS | SYSTEM-DEFINED ENTITIES | FEDERATIONS | DEPOTS AND SUBDEPOTS
| PACKAGES | ROUTINE HEADINGS | ROUTINE BODIES | INNER ROUTINE BODIES
)" and "SIMPLE GENERIC CATALOG COLLECTION TYPES" and "OLD TYPE
DEFINITIONS TO REWRITE OR REPLACE".
2008-04-21 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.26.0 is released on CPAN as
Muldis-D-0.26.0.tar.gz.
* New file versions are: D.pm 0.26.0 and Types_Catalog.pod 0.23.0 and
Routines.pod 0.22.0 and Basics.pod 0.19.0 and PTMD_Tiny.pod 0.18.0 and
HDMD_Perl_Tiny.pod 0.15.0. The other pre-existing versioned files are
unchanged.
* (Basics.pod, PTMD_Tiny.pod) Renamed the routine kind 'main' to
'bootloader' and updated its description. This routine kind is now not
so much a "main program" as it is more like a thin wrapper that loads
and invokes the main from a depot. A bootloader can be used by both
plain text and hosted data Muldis D, not just the former; it can also
be split into pieces. Also added the bootloader_exclusive routine kind
which is a system service that can only be called by a bootloader,
examples being distinct transaction initiation and termination
statements. Most updates were in the ROUTINES and TRANSACTIONS AND
CONCURRENCY and RESOURCE MODULARITY AND PERSISTENCE sections of
Basics.pod, and in the DESCRIPTION of PTMD_Tiny.pod.
* (Routines.pod) Added new SYSTEM-DEFINED CORE BOOTLOADER EXCLUSIVES
with 3 new sys.Core.Control.(start|commit|rollback)_trans routines.
* (Basics.pod) In the ENTITY NAMES section, refactored the
fed|dep|sdp|pkg namespaces so that each has cat|lib|data secondary
namespaces. The 'lib' namespace retains the type and routine
invocation names while 'data' now represents a dbvar and it replaces
all the '<relvar>'; this change was made to emphasize the fact that
there is just a single global variable (per scope) for user data, and
that relvars are just pseudo-variable components of a dbvar. The new
'cat' secondary namespaces, each a dbvar, are now the parts of the
system catalog for user-defined entities, and the 'cat' primary
namespace is now just a dbcon for system-defined entities. Added new
'mnt' primary namespace catalog dbvar to countrol what depot mounts
exist, rather than that being under the 'cat' primary. Also indicated
that type definitions can have inner routines, and routine definitions
can have inner types; that is there are both inner and outer types now.
* (Basics.pod) In ENTITY NAMES, added "Terse Pseudo-Variable Syntax"
section which specifies that you can indeed use extended entity names
to directly reference components of eg tuples, such as by writing
"tupvar.attrname" rather than having to say "attr( tupvar, attrname )"
or "assign( tupvar.attrname, 42 )" rather than "assign( tupvar,
update_attr( tupvar, attrname, 42 ) )".
* (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Formalized
the Cat.NameChain type with actual possrep names, and updated it to
require a minimum of 2 chain elements; also deleted the superfluous
types Cat.NESeqOfName and Cat.FlattenedNameChain, which have been
merged into Cat.NameChain as informal inner types.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Supplemented the HDMD_Perl_Tiny
dialect so you can define whole bootloader routines in it as you
already could with the PTMD_Tiny dialect; added 2 new pod sections /
PHMD node types BOOTLOADER and BOOTLOADER PROCEDURE CALL. Updated the
PTMD_Tiny dialect to rename the 'start' token to 'bootloader', and
'procedure_call' to 'bootloader_procedure_call'; the latter now starts
with the literal text 'boot_call' rather than 'Call'.
2008-04-13 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.25.1 is released on CPAN as
Muldis-D-0.25.1.tar.gz.
* New file versions are: D.pm 0.25.1 and Basics.pod 0.18.1 and
SeeAlso.pod 0.4.1. The other pre-existing versioned files are
unchanged.
* (D.pm, Basics.pod, SeeAlso.pod) A few minor updates to reflect the
fact that the Muldis D main reference implementation is now named
Muldis Rosetta rather than Muldis DB.
2008-04-07 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.25.0 is released on CPAN as
Muldis-D-0.25.0.tar.gz.
* New file versions are: D.pm 0.25.0 and Types.pod and
Types_Catalog.pod and Ordered.pod and Integer.pod and Blob.pod and
Text.pod and Set.pod and Sequence.pod and Bag.pod and Rational.pod
0.22.0 and Basics.pod 0.18.0 and PTMD_Tiny.pod 0.17.0 and
HDMD_Perl_Tiny.pod 0.14.0 and Temporal.pod and Spatial.pod 0.7.0. The
other pre-existing versioned files are unchanged.
* (D.pm) The TRADEMARK POLICY section was severely edited to excise
most legalese, and is now just half its previous size; the old longer
version was shunted off to the Muldis Data Systems' website.
* (D.pm, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Renamed the quasi-constant
second (authority) part of a fully-qualified name format for a Muldis D
language variant, applicable only to the official/original (not
embraced and extended) variants, from 'cpan:DUNCAND' to
'http://muldis.com'. This is because the main web address of Muldis
Data Systems more closely represents the official authority on Muldis
D, rather than CPAN which is more just a forum for publishing it.
* (Basics.pod, PTMD_Tiny.pod) Updated the "main" routine kind to
specify that it can not have any lexical variables or inner routines;
all a "main" can do is invoke procedures that have no subject-to-update
parameters.
* (Basics.pod) The standard system-defined entities may now have fully
qualified names that are 3 or more parts (including the "sys") rather
than exactly 4 parts, which allows for more elegant naming schemes.
* (Types.pod, Types_Catalog.pod, HDMD_Perl_Tiny.pod, Integer.pod,
Blob.pod, Text.pod, Rational.pod, Temporal.pod, Spatial.pod) Renamed
all the data types declared in Types.pod to substitute 'Type' for
'(Universal|((|Quasi)(Scalar|Tuple|Relation)|Remnant|Spec)'; then
renamed the 4 'D0' types to distinguish them again, and renamed 'E_D'
to 'QuasiScalarDVPT'. Renamed all the data types declared in
Types_Catalog.pod to insert a '.Type' before their '.(|Quasi)Cat'.
Then all the Core types were named 'sys.Core.Type(|.(|Quasi)Cat).\w+'.
Renamed all the data types declared in
(Integer|Blob|Text|Rational|Spatial).pod so that they have names like
'sys.<extension>.Type.\w+'; the previous 3rd name part was either
redundant with the extension name or was '(Cat|Spec)'. Renamed all the
data types declared in Temporal.pod from 'sys.Temporal.(With|No)TZ.\w+'
to 'sys.Temporal.Type.\w+(With|No)TZ'.
* (Ordered.pod, Integer.pod, Blob.pod, Text.pod, Set.pod, Sequence.pod,
Bag.pod, Rational.pod) Renamed all the routines whose third name parts
were redundant with their second name parts, to remove the third parts.
* (Types.pod, Integer.pod, Rational.pod) Removed the system-defined
types NE(Blob|Text) and updated the few system-defined functions using
them to use Blob|Text instead.
* (Types_Catalog.pod, Integer.pod, Rational.pod) Removed the
Cat.PInt2_36 type from the core and placed duplicate copies of it under
altered names in both the integer and rational extensions.
* (Types_Catalog.pod) Updated the DESCRIPTION, as well as the Name and
Comment descriptions.
* (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Updated the
Cat.E_ENK and Cat.E_PSAK types to remove each of their 'default'
values. Users now always specify the use of type-default values
explicitly, using either generic literal or function invocation
expressions, which makes user code more self-documenting and saves on
some catalog complexity; that said, some Muldis D dialects may still
have a short-hand for 'default'.
* (Types_Catalog.pod) Updated the Cat.ExprNode and Cat.ProcStmtArg
types to remove each of their 'type' attributes. Users now always do
an explicit 'treated' func call when they need to, or otherwise the
data type at each of these nodes is now just inferred from context, and
so Muldis D is now more like a typical programming language as to what
it requires users to explicitly say.
2008-03-22 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::D version 0.24.0 is released on CPAN as
Muldis-D-0.24.0.tar.gz.
* What was Language-MuldisD at version 0.23.0 has been renamed to
Muldis-D. This is the first release of the Muldis-D distribution, and
the first release of any distribution to contain Perl 5 package names
like Muldis::D(|::\w+). All of the files in this distribution are as
identical as possible to how they were when last released under the
names Language::MuldisD(|::\w+) but for the name changes. All lib/
files were renamed appropriately, and also the one t/LMD_00_Compile.t
was renamed to t/Muldis_D_00_Compile.t.
* All versioned files had their version numbers incremented to the
first higher 0.N.0. New file versions are: D.pm 0.24.0 and Core.pod
and Types.pod and Types_Catalog.pod and Routines.pod and Ordered.pod
and Integer.pod and Blob.pod and Text.pod and Nonscalar.pod and Set.pod
and Sequence.pod and Bag.pod and Rational.pod 0.21.0 and Basics.pod
0.17.0 and PTMD_Tiny.pod 0.16.0 and HDMD_Perl_Tiny.pod 0.13.0 and
Temporal.pod and Spatial.pod 0.6.0 and SeeAlso.pod 0.4.0 and
Hierarchical.pod and Conventions.pod 0.1.0.
* Updated D.pm and the README file to clarify that commercial support
is available from the author specifically by way of Muldis Data
Systems.
* Updated all .pm and .pod files to add a new TRADEMARK POLICY section
near the end of each; it serves for trademarks what the LICENSE AND
COPYRIGHT did for copyrights. The D.pm file had the actual text, and
the other files simply say to look at D.pm. To summarize, the word
MULDIS is a trademark and how you may use it has limitations.
* (SeeAlso.pod) Updated the "Muldis DB for Perl 6" implementation
reference to say that it is now a secondary version, and that the Perl
5 version is now the only main muldis D implementation. Generally
speaking, it does not help the adoption of Muldis D if we are giving
the impression that it has a dependency that most people don't have
and/or isn't ready for production use, namely Perl 6, and Perl 5 should
be given more support in the meantime.
* (Basics.pod, Ordered.pod) Minor fixes.
* This is the Muldis-D-0.24.0 file manifest:
Changes
INSTALL
lib/Muldis/D.pm
lib/Muldis/D/Basics.pod
lib/Muldis/D/Conventions.pod
lib/Muldis/D/Core.pod
lib/Muldis/D/Core/Routines.pod
lib/Muldis/D/Core/Types.pod
lib/Muldis/D/Core/Types_Catalog.pod
lib/Muldis/D/Dialect/HDMD_Perl_Tiny.pod
lib/Muldis/D/Dialect/PTMD_Tiny.pod
lib/Muldis/D/Ext/Bag.pod
lib/Muldis/D/Ext/Blob.pod
lib/Muldis/D/Ext/Integer.pod
lib/Muldis/D/Ext/Nonscalar.pod
lib/Muldis/D/Ext/Ordered.pod
lib/Muldis/D/Ext/Rational.pod
lib/Muldis/D/Ext/Sequence.pod
lib/Muldis/D/Ext/Set.pod
lib/Muldis/D/Ext/Spatial.pod
lib/Muldis/D/Ext/Temporal.pod
lib/Muldis/D/Ext/Text.pod
lib/Muldis/D/Hierarchical.pod
lib/Muldis/D/SeeAlso.pod
LICENSE/GPL
Makefile.PL
MANIFEST
MANIFEST.SKIP
META.yml
README
t/Muldis_D_00_Compile.t
TODO
2008-03-22 Darren Duncan <darren@DarrenDuncan.net>
The next version of the Module List will list the following module:
modid: Muldis::D
DSLIP: cmong
description: Formal spec of Muldis D relational DBMS lang
userid: DUNCAND (Darren Duncan)
chapterid: 7 (Database_Interfaces)
enteredby: BDFOY (brian d foy)
enteredon: Sat Mar 22 22:41:26 2008 GMT
The resulting entry will be:
Muldis::
::D cmong Formal spec of Muldis D relational DBMS lang DUNCAND
2008-03-22 Darren Duncan <darren@DarrenDuncan.net>
Record update in the PAUSE modules database:
modid: [Language::MuldisD]
statd: [c]
stats: [m]
statl: [o]
stati: [n]
statp: [g]
description: [Formal spec of Muldis D relational DBMS lang]
userid: [DUNCAND]
chapterid: [7]
mlstatus: [delete] was [list]
2008-03-05 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.23.0 is released on CPAN as
Language-MuldisD-0.23.0.tar.gz.
* Reverted the only change made in release 0.22.1, by recombining the 6
files Core(|/\w+).pod back into the single file Core.pod; it would then
be split apart again but in a different way. For simplicity of
documentation, the rest of the release 0.23.0 change items are written
from the point of view of starting with the combined Core.pod.
* Pulled apart Core.pod to turn as much of it as possible into language
extensions, leaving the remaining core as minimalist as possible, such
that it contains barely more than what is needed to both bootstrap the
Muldis D language and satisfy the mandatory parts of "The Third
Manifesto". The minimized core still provides the full system catalog
complexity, but has relatively few system-defined generic data types
and system-defined operators. There were 9 new Ext/\w+.pod files
created out of the reductions: Ordered.pod, Integer.pod, Blob.pod,
Text.pod, Nonscalar.pod, Set.pod, Sequence.pod, Bag.pod, Rational.pod.
Details of what each contains appear below.
* Re-split apart Core.pod 4 ways, into itself and 3 new files, all of
which have the same names of and correspond to the files of the same
names that release 0.22.1 had: Types.pod, Types_Catalog.pod,
Routines.pod. In that respect, then, release 0.23.0 actually served to
just eliminate the 2 files Functions_(S|Nons)calar.pod, whose contents
were either merged into Routines.pod or spread out into the 9 new Ext
files; and some smaller portions of Types(|_Catalog).pod were also
moved out into some of the 9 new Ext files. Details pre-split follow.
* New file versions are: MuldisD.pm 0.23.0 and Core.pod and Types.pod
and Types_Catalog.pod and Routines.pod and Ordered.pod and Integer.pod
and Blob.pod and Text.pod and Nonscalar.pod and Set.pod and
Sequence.pod and Bag.pod and Rational.pod 0.20.0 and Basics.pod 0.16.0
and PTMD_Tiny.pod 0.15.0 and HDMD_Perl_Tiny.pod 0.12.0 and Temporal.pod
0.5.3. The other pre-existing versioned files are unchanged.
* (Ordered.pod, Core.pod, Temporal.pod) Removed the Ordered union
type; from now on, any type is potentialy orderable based on what
functions exist for it, not by its type declaration. Also removed the
4 Spec.\w+ofOrdered types. Any routine declarations that used Ordered
before now use Universal instead. Moved all sys.Core.Ordered.\w+
functions to Ordered.pod from Core.pod, renaming them to
sys.Ordered.Ord.\w+.
* (Core.pod) Removed the Cat.ScalarLiteral type; from now on, the
limitations of what values can be used for the scal_lit attribute of
Cat.ExprNode are either dialect-defined or implementation-defined; all
others can still be defined using the 'func' attribute.
* (Basics.pod, Rational.pod, Core.pod, PTMD_Tiny.pod,
HDMD_Perl_Tiny.pod) Demoted the Rat types from the language core into
a language extension. Moved all sys.Core.Rat.\w+ types (plus the
sys.Core.Spec\w+ofRat types) and functions to Rational.pod from
Core.pod, renaming the 'Core' to 'Rational'. Likewise moved and renamed
the 3 rational-specific catalog types [PInt2_N, E_RM, RatRoundRule].
Updated Basics.pod to reflect this. Rearranged PTMD_Tiny.pod and
HDMD_Perl_Tiny.pod to move their elements for Rat and E_RM literals to
the end of the files, where language extension literals now go.
* (Integer.pod, Core.pod) Moved all sys.Core.Int.\w+ functions (plus
the sys.Core.Spec\w+of(Int|UInt) types) to Integer.pod from Core.pod,
renaming the 'Core' to 'Integer'.
* (Blob.pod, Core.pod) Moved all sys.Core.Blob.\w+ functions (plus the
sys.Core.Spec\w+ofBlob types) to Blob.pod from Core.pod, renaming the
'Core' to 'Blob'. Likewise moved and renamed the blob-specific catalog
type PInt1_4.
* (Text.pod, Core.pod) Moved all sys.Core.Text.\w+ functions (plus the
sys.Core.Spec\w+ofText types) to Text.pod from Core.pod, renaming the
'Core' to 'Text'.
* (Core.pod, HDMD_Perl_Tiny.pod) Renamed all 8
sys.Core.(Bool|Int|Text|Blob).\w+ remaining types to
sys.Core.Scalar.\w+. So now all the generic core types have names in
the just 8 main type groupings: Scalar, Tuple, Relation, their 3 Quasi
counterparts, Universal, Remnant.
* (Core.pod) Removed the 4 Spec.\w+ofScalar types. So now the only
similar such types left in the core are the 4 Spec.\w+ofBool ones;
collapsed the mention of them under TYPE SUMMARY into a footnote.
* (Nonscalar.pod, Core.pod) Moved 31 (about 3/7) of the
sys.Core.(Tuple|Relation).\w+ functions to Nonscalar.pod from Core.pod,
renaming the 'Core' to 'Nonscalar'. The moved were in 5 groups, the
first being all Tuple.\w+, the remaining 4 all Relation.\w+. Group 1
had these 4: degree, attr_from_Tuple, Tuple_from_attr,
substitution_in_default. Group 2 had these 11: degree,
is(|_not)_empty, empty, universal, power_set, negation,
transitive_closure, (|maybe_)reduction, map. Group 3 had these 5:
is(|_not)_proper_subset, exclusion, composition, join_with_group. Group
4 had these 6: (|static_)substitution(|_in_(restriction|semijoin)).
Group 5 had these 5:
outer_join_with_(group|maybes|defaults|product|extension).
* (Set.pod, Core.pod) Moved all sys.Core.(Set|Maybe).\w+ functions to
Set.pod from Core.pod, renaming the 'Core' to 'Set'.
* (Sequence.pod, Core.pod) Moved all sys.Core.Seq.\w+ functions to
Sequence.pod from Core.pod, renaming the 'Core' to 'Sequence'.
* (Bag.pod, Core.pod) Moved all sys.Core.Bag.\w+ functions to Bag.pod
from Core.pod, renaming the 'Core' to 'Bag'.
* Following all the above moves, there were 56 operators (53 functions,
1 updater, 2 procedures) remaining in Core.pod; of those, the
'Universal' namespace had 5 functions and 1 updater, the 'Bool'
namespace had 6 functions, the 'Tuple' namespace had 10 functions, the
'Relation' namespace had 33 functions, and the 'Control' namespace had
2 procedures.
2008-02-29 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.22.1 is released on CPAN as
Language-MuldisD-0.22.1.tar.gz.
* This release takes place on a rare February 29th.
* This release is minimalist and serves only to split up the file
Core.pod into itself plus 5 new files, all named Core/\w+.pod:
Types.pod, Types_Catalog.pod, Routines.pod, Functions_Scalar.pod,
Functions_Nonscalar.pod. This split was done mainly to make the
information easier to maintain and to read. Where the original file
was 168KB, the largest of the new files is 60KB.
* New file versions are: MuldisD.pm 0.22.1 and Core.pod 0.19.1 (all 5
Core/\w+.pod started at 0.19.1 also). The other pre-existing versioned
files are unchanged.
2008-02-26 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.22.0 is released on CPAN as
Language-MuldisD-0.22.0.tar.gz.
* New file versions are: MuldisD.pm 0.22.0 and Core.pod 0.19.0 and
Basics.pod 0.15.0 and PTMD_Tiny.pod 0.14.0 and HDMD_Perl_Tiny.pod
0.11.0. The other pre-existing versioned files are unchanged.
* (Basics.pod) Added new "Numeric Types" pod subsection under TYPE
SYSTEM, which outlines what features concerning numeric data are and
are not provided by the Muldis D language core. To summarize, the core
numerics are all exact radix-independent "bignum", suitable for all
magnitude of rational or floating-point numbers; no special values like
NaNs or infinities are provided, they are left to language extensions.
* (Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Renamed the rounding
method 'to_even' to 'half_even' and added 2 more rounding methods
'half_down' and 'to_inf'; the 2 complement 'half_up' and 'to_zero'.
* (Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Enhanced the Rat
numeric type so it now has 2 actual possreps, defined over Ints, called
'ratio' (2 attrs) and 'float' (3 attrs), rather than having zero actual
possreps and just a conceptual ratio one. The 'float' possrep is
intended to make it easier to deal with numbers in scientific notation,
which is particularly useful for very large or very small numbers.
Added the 4 functions Rat.Rat_from_Int_triple and
Rat.(mantissa|radix|exponent) to reflect the 'float' possrep. (But
note that these such functions are deprecated for generic scalar ones.)
In PTMD_Tiny, added a third format for specifying Rat literals, named
'float', which looks like 'Rat:float:9:314159*10^-5'; also renamed the
'pair' format to 'ratio'. In HDMD_Perl_Tiny, updated the PHMD node for
Rat literals to add some 'float' formats and rename the 'pair' formats.
2008-02-15 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.21.0 is released on CPAN as
Language-MuldisD-0.21.0.tar.gz.
* New file versions are: MuldisD.pm 0.21.0 and Core.pod 0.18.0 and
Basics.pod 0.14.1 and PTMD_Tiny.pod 0.13.0 and HDMD_Perl_Tiny.pod
0.10.0. The other pre-existing versioned files are unchanged.
* (MuldisD.pm, Basics.pod) Updated the paradigm list of Muldis D to
add the word "homoiconic", which I just learned about today and which
is strongly descriptive of any "D" language, especially of Muldis D.
* (Basics.pod, Core.pod) Renamed the 'treat' function to 'treated';
renamed the 'v' parameter of that and the 'is_value_of_type' function
to 'topic'.
* (Core.pod) Updated the notes on a complete tuple|relation types'
cardinalities to say specifically how to calculate them, rather than
generally saying it is done using permutations.
* (Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Added new scalar
catalog data type sys.Core.Cat.Comment which represents a Muldis D code
comment that programmers can attach to various catalog elements; it is
also useful for preserving comments translated to/from other languages.
This type is the same as Text|Name but is disjoint from both. Also
added a new Comment token or PHMD node type to both Tiny dialects.
* (Core.pod) Updated most (11) of the tuple catalog types to add a
'comment' attribute to each, so code comments can be attached to code
in the most appropriate places possible, such as to individual
expression nodes or to whole statements or to whole routines.
* (Core.pod) Updated the 2 functions sys.Core.Relation.un(wrap|group)
to add the new 'inner' argument, which resolves ambiguity of what
attribute names are being added for the result when the input relation
has no tuples (and the MST of every input relation attribute is Empty).
* (Core.pod) Added the 4 functions
Relation.static_(extension|substitution(|_in_(restriction|semijoin)))
which are all simpler-syntax versions their 'static_'-less counterparts
where the values being added or substituted are the same for every
tuple, so there is no need to incur a conceptual function call per
input tuple. So now every Muldis D function with a function parameter
now has an alternate specialized variant which handles certain common
cases, without a function parameter.
* (Core.pod) Added the function sys.Core.Tuple.multi_update as a
short-hand for multiple update_attr; in fact it is necessary in cases
where the latter would otherwise be used but a type constraint would
require multiple attribute updates as a unit.
* (Core.pod) Added the function sys.Core.Tuple.substitution_in_default
which should help users write less verbose Muldis D code where they can
just specify parts of a desired tuple value and let the rest be filled
in with default attributes for the desired tuple's type.
* (PTMD_Tiny.pod) Updated specifier for called procedure name so it
can be in both formats that a Cat.NameChain can have.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Added support for
quasi-nonscalar literals as per nonscalar literals.
2008-02-07 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.20.0 is released on CPAN as
Language-MuldisD-0.20.0.tar.gz.
* New file versions are: MuldisD.pm 0.20.0 and Core.pod 0.17.2 and
Basics.pod 0.14.0 and PTMD_Tiny.pod 0.12.0 and HDMD_Perl_Tiny.pod 0.9.0
and SeeAlso.pod 0.3.4. The other pre-existing versioned files are
unchanged.
* (MuldisD.pm, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Renamed the constant
first part of a fully-qualified name format for a Muldis D language
variant, from 'MuldisD' to 'Muldis_D'. This is to help not perpetuate
the myth that the normal/correct way to spell the language name is with
MuldisD (1 word) rather than Muldis D (2 words); I have already seen a
number of places using that shortened form, incorrectly. Note that the
only reason the package name has them rammed together is because that
is normal practice for Perl namespaces, which the spec is written
under.
* (Basics.pod, Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod,
SeeAlso.pod) Rewrote the "Representation" POD sub-section of the
"MULDIS D" POD main section of Basics.pod, which included renaming the
"Concrete" and "Abstract" dialect groupings to "Plain Text" and "Hosted
Data". Then renamed any references to said groupings in all 5 files.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Rewrote most of the DESCRIPTION
pod in light of both the "Representation" change and MuldisD.pm's new
VERSIONING section, to conform to them and remove redundancies. Also
smaller changes for the same reasons in other parts of the 2 Tiny
files. In HDMD_Perl_Tiny.pod, split the GENERAL STRUCTURE pod section
into itself and LANGUAGE NAME, the latter portion being rewritten.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Shortened the syntax for a
Cat.Name value, which huffmanizes the grammars more and also allows
other improvements. The cat_name grammar token no longer specifies a
"Cat.Name:" prefix, and the Cat.Name phmd node is now simply a Perl Str
rather than being a 2-element Array; any parsing context that is
expecting a generic literal grammar token or generic phmd node will
interpret a character string without metadata as being a Cat.Name.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Updated every nonscalar literal
grammar token and phmd node to remove its element that specifies a
predefined type name which constrains/defines the literal's heading.
This metadata was verbosity that couldn't really be used except within
the DBMS, wherein it already existed there in code definitions that is
processing the literals. As an exception to this straight-removal, for
plain relation literals, a new replacement feature was added for the
removed, which specifies the relation's attribute list when the
relation has no tuples to provide that information. Given that this
attribute list is formatted differently than a tuple list, just one of
those things appears in a relation literal, and a parser can easily
distinguish between them.
* (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Fleshed out or fixed the
syntaxes for specifying Cat.NameChain literals.
* (PTMD_Tiny.pod) Added the syntax to call procedures, thus making a
PTMD_Tiny code file actually able to represent a Muldis D 'main'
routine, and hence actually represent a program; which is simply a
sequence of procedure calls following a language name declaration. The
literal-defining syntax which still makes up most of the grammar is now
specifically for defining arguments for the procedure calls
2008-02-07 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.19.1 is released on CPAN as
Language-MuldisD-0.19.1.tar.gz.
* This release is very minimalist, serving to rename a few files, and
do as little as possible otherwise. It seemed best to do all actual
file content changes separately, so that it is easy to do
same-file-name diffs on consecutive distro versions and see what
content changed.
* Renamed Grammar.pod to Dialect/PTMD_Tiny.pod, and PerlHosted.pod to
Dialect/HDMD_Perl_Tiny.pod. Correspondingly renamed the pseudo-package
names (what the NAME pod says) in those files. Then updated all the
other distro files to refer to the 2 renamed by their new names.
* New file versions are: MuldisD.pm 0.19.1 and Core.pod 0.17.1 and
Basics.pod 0.13.1 and PTMD_Tiny.pod 0.11.1 and HDMD_Perl_Tiny.pod 0.8.1
and Hierarchical.pod 0.0.3. The other pre-existing versioned files are
unchanged.
2008-02-03 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.19.0 is released on CPAN as
Language-MuldisD-0.19.0.tar.gz.
* New file versions are: MuldisD.pm 0.19.0 and Core.pod 0.17.0 and
Basics.pod 0.13.0 and Grammar.pod 0.11.0 and PerlHosted.pod 0.8.0 and
Hierarchical.pod and Conventions.pod 0.0.2. The other pre-existing
versioned files are unchanged.
* (MuldisD.pm) Added new main pod section VERSIONING which explains
the fully-qualified name formats of Muldis D variants in a generic
manner, so to help make the Muldis D code more future-proof. Updated
the related DESCRIPTION paragraph.
* (Basics.pod, Core.pod) Renamed the 2 operators is(|_not)_equal to
is(|_not)_identical, which is arguably less ambiguous on what they are
testing for. Also renamed their parameters from v(1|2) to
(topic|other); the parameters are still commutative, though.
* (Core.pod) Renamed the 2 operators is_(increase|decrease_or_same) to
is(|_not)_before, and eliminated the 2 operators
is_(decrease|increase_or_same); considering that all Muldis D
parameters are named rather than ordered, the eliminated operators are
completely redundant with invoking the 2 kept ones with the arguments
swapped, and order-specific variants are not helpful. Also renamed
their parameters as per the is_identical change. This elimination also
brings more parity with other parts of the language that considered
only-position-swapped variants useless, such as the presence of
is_subset but no is_superset.
* (Core.pod, Grammar.pod, PerlHosted.pod) Eliminated the Cat.Order
type, which currently doesn't seem to be that useful after all (if this
judgement was wrong, it could be brought back later). Eliminated the
corresponding grammar token and PHMD node kind. Eliminated the 2
Ordered.(|reverse_)comparison functions. Eliminated the 4
Cat.Order_\w+ functions.
* (Core.pod, Grammar.pod, PerlHosted.pod) Renamed the Just type to
Single (and QuasiJust to QuasiSingle); while breaking from the
Haskell-inspired triple, it reads better for Muldis D, and is more
descriptive.
* (Core.pod) Added 3 functions sys.Core.Maybe.(nothing|single|attr)
where the first 2 will select a Nothing or Single value respectively,
and the last one will extract the payload of a known-Just value.
* (Core.pod) Renamed the 2 functions Int.(in|de)crease to
Int.(in|de)crement.
* (Core.pod) Added an initial complement of 5 relational functions to
do half-outer natural joins in different ways,
Relation.outer_join_with_(group|maybes|defaults|product|extension);
also added inner join variant of the first, Relation.join_with_group.
The 2 'group' functions are intended as convenient tools for gathering
both parent and child records from a database using a single query
while avoiding duplication of the parent record values.
* (Core.pod, Hierarchical.pod, Conventions.pod) Other minor updates.
2008-01-25 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.18.0 is released on CPAN as
Language-MuldisD-0.18.0.tar.gz.
* New file versions are: MuldisD.pm 0.18.0 and Core.pod 0.16.0 and
Basics.pod 0.12.0 and Grammar.pod 0.10.0 and PerlHosted.pod 0.7.0 and
Hierarchical.pod and Conventions.pod 0.0.1. The other pre-existing
versioned files are unchanged.
* (Basics.pod) Updated TYPE SYSTEM to remove the requirement where
every value must have exactly one most-specific-type / MST, which is
supposed to exist in a generic "D" language to assist some kinds of
polymorphism. Although that restriction is still generally followed
for all system-defined types, and it would ideally be the case for all
user-defined types, the design of Muldis D does not generally require a
value to have a single MST in order to work, and moreover to enforce
the single-MST requirement would place an undue burden on users, who
would typically need to define many gratuitous types to satisfy it.
* (Basics.pod) Updated the "Tuple Types and Relation Types" subsection
of TYPE SYSTEM to directly explain that any 2 zero-tuple relation
values of the same degree and with the same attribute names are
considered identical, regardless of the declared types of those
attributes in the code that produced them; every attribute of a
zero-tuple relation value has an MST of Empty, which is a subtype of
every other type. A consequence is that every Set|Maybe or Seq or Bag
type's single zero-tuple value is identical to every other's one.
* (Core.pod) Further echoing the design of Haskell's "Maybe" feature,
added 2 complementary subtypes of Maybe named
sys.Core.Relation.(Nothing|Just), which have exactly zero tuples or 1
tuple, respectively; the Nothing type has exactly 1 value of Maybe, and
the Just type has all the rest of them. Nothing is Muldis D's answer
to the SQL NULL, in that it is meant as a marker that a value is
unknown or inapplicable; but unlike SQL, Nothing is an actual value,
and it does equal itself. Just is the same container, that always does
hold exactly one value. Also added the 2 subtypes Quasi(Nothing|Just).
* (Grammar.pod, PerlHosted.pod) Took the explicit grammar token or
PHMD node type specific to the Maybe type, and replaced it with two
that are specific to the Nothing or Just types, where each
more-specialized replacement has simpler syntax than what it replaced.
* (Basics.pod, Core.pod, Grammar.pod, PerlHosted.pod) Rounded out /
added better symmetry to the type system by adding the concept of a
quasi-scalar type and adding the system-defined QuasiScalar maximal
type. Since there are no normal system-defined quasi-scalar types from
which that new maximal would draw a default value (all normal
quasi-scalar types are expected to be user-defined, if they exist at
all), also added the QuasiScalar.E_D subtype which exists soley for
that purpose. Also added the system-defined Remnant maximal type, and
that already had the pre-existing ScaTupRel normal system-defined type
from which to draw a default value.
* (Core.pod) Removed the ExprNode|ProcStmtArg attribute 'tk' and
InnerFunc attribute 'result_tk', due to seemingly not being too useful.
* (Core.pod) Added constraint to trees of expression nodes or inner
routines such that any node which is the sole tree root in its context
must have the empty string as its name. These 4 catalog data types now
have that constraint added: ExprTree, Inner(Func|Updater|Proc)Tree.
Removed the no-longer-needed 'root_\w+' attribute from each of these 4
catalog data types: InnerFunc, Func, Updater, Proc. Some small fixes.
* (Core.pod) Added the 2 functions Ordered.is_(in|de)crease_or_same,
which are to is_(in|de)crease what '>='|'<=' are to '>'|'<'. With this
addition, all 6 of the common dyadic compare operators [=,!=,<,>,<=,>=]
are directly represented, so no need to emulate over several functions.
* (Core.pod) Added the 3 functions Relation.disjoint_(insertion|union)
and Set.disjoint_insertion; they are the same as the non-disjoint
versions but that they fail if there are duplicate tuples|elements
rather than succeeding as a full or partial no-op.
* (Basics.pod, Core.pod, Hierarchical.pod, Conventions.pod) Other
minor updates.
2008-01-12 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.17.0 is released on CPAN as
Language-MuldisD-0.17.0.tar.gz.
* New file versions are: MuldisD.pm 0.17.0 and Core.pod 0.15.0 and
Grammar.pod 0.9.0 and PerlHosted.pod 0.6.0. The other pre-existing
versioned files are unchanged. Added 2 new files
lib/Language/MuldisD/Hierarchical.pod and
lib/Language/MuldisD/Conventions.pod, each of which start at version
0.0.0.
* (Core.pod) Updated the Cat.InnerFunc type to add a couple missing
attributes, result_tk and result_type.
* (Grammar.pod, PerlHosted.pod) Removed the explicit grammar tokens or
PHMD node types that were specific to these 7 Muldis D types: UInt,
PInt, URat, PRat, NEBlob, NEText, Database. So now just these 14 ones
are directly supported: Bool, Int, Rat, Blob, Text, Tuple, Relation,
Set, Maybe, Seq, Bag, Cat.Name, Cat.NameChain, Cat.Order. This change
was made to remove unnecessary complexity from the grammar/PHMD specs;
now for the most part there is now only 1 distinct grammar token or
PHMD node type for each core Muldis D root type (so the removed are
covered by their remaining parents); non-root types generally only have
their own when they also have a syntactic short-hand to take advantage
of. Any otherwise orphaned examples were updated to the parent syntax.
Also removed the 'index' variant of Seq from Grammar, leaving just the
ordered variant, which was all PerlHosted had anyway. And updated the
'count' variant of Bag to do itself what it had used a PInt token/node
to do.
* (Grammar.pod, PerlHosted.pod) Upgraded the specification formats for
rationals so that now any rational value can be directly selected, not
just those whose denominators are powers of 2..36; for example, you can
now select the rational 1/43 directly where you couldn't before. To
facilitate this, there are now 2 formats you can define a rational in,
the previous 'N.N' format, called 'radix', and the new 'N/N' format,
called 'pair'; in PerlHosted, the latter is given as 2 elements, not 1.
* (Grammar.pod, PerlHosted.pod) Added grammar tokens and PHMD node
types for all the not yet covered enumerated scalar catalog types:
Cat.E_RM, Cat.E_TK, Cat.E_TDM, Cat.E_ENK, Cat.E_PSAK. So that fills in
all the remaining gaps in those files and it is now possible to either
directly select any Muldis D value or directly define the system
catalog entries of any Muldis D code that would.
* (Hierarchical.pod) This new file has begun to outline an additional
official dialect of Muldis D, which is terse and intended for normal
use for writing code in, or writing code examples in, unlike the
'catalog' dialect which is damningly verbose for normal use.
* (Conventions.pod) This new file is a style guide, and mainly starts
off with suggesting good ways to name entities.
* (Core.pod) Other minor updates.
2008-01-05 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.16.0 is released on CPAN as
Language-MuldisD-0.16.0.tar.gz.
* This release coincides with the 5th anniversary of the first CPAN
release of the first Muldis D / Muldis DB progenitor; DBIx::Portable
version 0.01 was released on 2003 January 5th.
* New file versions are: MuldisD.pm 0.16.0 and Core.pod 0.14.0 and
Basics.pod 0.11.0 and Grammar.pod 0.8.0 and PerlHosted.pod 0.5.0. The
other pre-existing versioned files have their version numbers all
incremented by 0.0.1.
* (Basics.pod, Core.pod) Renamed the routine kinds update_operator and
inner_update_operator to the shorter 'updater' and 'inner_updater',
though the terms 'update operator' and 'updater' will continue to be
interchangeable. Also renamed 6 corresponding catalog types to
UpdStmt, MultiUpdStmt, InnerUpdater, InnerUpdaterSet, InnerUpdaterTree,
Updater, and renamed any referencing attributes as appropriate.
* (Core.pod) Reformatted all the routine signatures to look more
natural for Muldis D, rather than being mostly identical to the Perl 6
routine signature format. The format for function declarations is now
"function foo result Bar params { baz(Quux) }" rather than "foo of Bar
(Quux $baz)", and the format for updater or procedure declarations is
now "updater|procedure foo update { fi(Fum) } read { baz(Quux) }"
rather than "foo (UPD: Fum $fi ; RO: Quux $baz)". Note that this
version may not be final, and another reformat may likely come, though
that one would likely just consist of different keywords to replace
[result, params, update, read] and not other changes; feedback on this
is welcome.
* (Core.pod) Removed the 3 core pseudo-types
sys.Core.Some.(Universal|ScaTupRel|Ordered), and added the 1 core
remnant type sys.Core.Remnant.ScaTupRel; the new one replaces one of
the removed, and the other 2 removed are now just redundant with the
normal Universal and Ordered types. It seemed rather arbitrary that
some contexts (like routine signatures) which couldn't actually take
all combinations of their parameter types would in some cases have said
parameters documented as pseudo-types, other times as regular types.
* (Core.pod, Grammar.pod, PerlHosted.pod) Reversing one change made
for release 0.9.0, a Cat.Name is once again allowed to be the empty
string (like 'Text', not 'NEText'), and Cat.NameChain parts likewise.
* (Core.pod, Grammar.pod, PerlHosted.pod) Officially demoted the Order
type from a generic type to a catalog-specific type, since it isn't
really ever expected to be used in user data, but just routine
definitions. It was renamed from sys.Core.Order.Order to
sys.Core.Cat.Order, and the definition of the type was moved from the
generic scalars section to the catalog scalars section; it did not get
further renamed to 'E_FOO' as Order is still more special than the
average enum type as per the enum type Bool, if nothing else than for
directly corresponding to a concept in multiple other programming
languages such as Perl 6. In Core.pod, added new main pod section
SYSTEM-DEFINED CORE CATALOG FUNCTIONS and moved the Order routines
there, renaming each of them from Order.foo to Cat.Order_foo in the
process. In Grammar.pod, renamed the 'order' token to 'cat_order' and
moved it next to the existing catalog types; made other appropriate
updates there, and updates and moves in PerlHosted.pod.
* (Core.pod) Updated any routine signatures that specified some
collection-type parameters as Foo{Bar} so they spell it FooAsBar
instead. Also added a few explicitly system-defined Spec.FooOfBar that
didn't previously exist but were referred to by said routines.
* (Core.pod) Renamed the 3 scalar types Spec.PInt(1_4|2_(N|36)) to
Cat.PInt(1_4|2_(N|36)), moved to catalog types.
* (Core.pod) Renamed (from 'Spec') or added the following 9
quasi-catalog incomplete types, which are used only as the declared
types of some system-defined N-adic relational operators; all are in th
new package 'sys.Core.QuasiCat': (Set|Bag)Of(Tuple|Relation), SetOfBag,
MaybeOfTuple, SeqOfSeq, QuasiSetOf(Tuple|Relation). Moved to a new doc
section SYSTEM-DEFINED CORE QUASI-CATALOG PARAMETERIZED TYPES.
* (Core.pod) With the above 2 groups removed from 'Spec', that package
is now simply for conveniently system-defined collection-of-scalar
types that are likely to be used in user data, and many of which are
the declared types of N-adic system-defined scalar operators. Added
any of the following 32 subtypes that didn't previously exist:
sys.Core.Spec.(Set|Maybe|Seq|Bag)Of(Scalar|Ordered),
sys.Core.Spec.(Set|Maybe|Seq|Bag)Of(Bool|Int|UInt|Rat|Blob|Text).
* Brought the TODO file in line with recent progress, replacing the few
broad-scope line items with more detail-scope ones, added some
speculation items.
* Incremented all copyright year range-ends to 2008.
* (Core.pod) Other minor updates.
2007-12-31 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.15.0 is released on CPAN as
Language-MuldisD-0.15.0.tar.gz.
* New file versions are: MuldisD.pm 0.15.0 and Core.pod 0.13.0 and
Basics.pod 0.10.3. The other pre-existing versioned files are
unchanged.
* (Core.pod) Renamed the type sys.Core.Int.PInt2_N to
sys.Core.Spec.PInt2_N and moved its declaration downwards.
* (Core.pod) Generally speaking, Muldis D now requires that for any
defined relation type, there is a corresponding (same heading) tuple
type also defined; the reverse is not true, though. To be specific,
any relation type is defined over the type that its tuples must be; a
tuple type definition covers the minimal required relational heading.
* (Core.pod) Added the 6 tuple type factories
(|Quasi)(Set|Seq|Bag)Elem, which have the same headings as the 6
existing relation type factories (|Quasi)(Set|Seq|Bag).
* (Core.pod) Renamed Cat.(|SetOf)NameMap to Cat.(|SetOf)NameExprMap,
and renamed its attributes from 'key','value' to 'name','expr'. Also,
as a reversal of one change made for release 0.8.0, renamed
Cat.BiDiNameMap to Cat.AttrRenameMap, and renamed its attributes from
'key','value' to 'before','after'. The latter is therefore no longer a
subtype of (the first of) the former.
* (Core.pod) Fleshed out the catalog types so that they can now fully
define expression trees and functions (except where new data types are
also required). Renamed the enumerated type Cat.E_EK to Cat.E_ENK.
Renamed the tuple type Cat.Expr to Cat.ExprNode, and added a 9th 'tk'
attribute to it. Added 6 new tuple|relation catalog types Cat.ExprSet,
Cat.ExprTree, Cat.InnerFunc, Cat.InnerFuncSet, Cat.InnerFuncTree,
Cat.Func.
* (Core.pod) Fleshed out the catalog types so that they can now fully
define multi-update statements and multi-update operators (as per
above). Building on the expr/func stuff, added 6 new tuple|relation
catalog types Cat.UpdateStmt, Cat.MultiUpdateStmt, Cat.InnerUpdateOper,
Cat.InnerUpdateOperSet, Cat.InnerUpdateOperTree, Cat.UpdateOper. Also
added 2 more values to the Cat.E_ENK type, '(upd|ro)_param', and then
generalized Cat.Expr so it can be used with subject-to-update
params/args to define pseudo|virtual-variables. So the composition of
an update operator definition is mostly expression nodes like with the
composition of functions. Note that presumably the Muldis D provision
of updateable virtual relvars (aka SQL's "views") would be provided as
an abstraction over functions and update operators, or some such.
* (Core.pod) Fleshed out the catalog types so that they can now fully
define non-atomic statements and procedures (as per above). Building
on the expr/func/upd stuff, added 1 new scalar catalog type Cat.E_PSAK
and 7 new tuple|relation catalog types Cat.ProcStmtArg,
Cat.ProcStmtArgSet, ProcStmt, Cat.SeqOfProcStmt, InnerProc,
Cat.InnerProcTree, Cat.Proc.
* (Core.pod) Added 8 generic reduction operators
'sys.Core.(Relation|Set|Seq|Bag).(|maybe_)reduction', so users can more
easily write their own N-adic reduction operators.
* (Core.pod) Added initial complement of 11 Seq-specific functions,
besides the 2 aforementioned: 'value', 'update_value', 'insertion',
'deletion', 'is_element', 'is_not_element', 'catenation', 'repeat',
'reverse', 'is_subseq', 'is_not_subseq'.
* (Basics.pod, Core.pod) Other minor updates.
2007-12-18 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.14.0 is released on CPAN as
Language-MuldisD-0.14.0.tar.gz.
* This release coincides with the 20th birthday of Perl; Larry Wall
released Perl 1 to the public on 1987 December 18th. Moreover, on this
20th birthday is the general/stable release of Perl 5.10, its best yet.
* New file versions are: MuldisD.pm 0.14.0 and Core.pod 0.12.0 and
Basics.pod 0.10.2 and Grammar.pod 0.7.2 and PerlHosted.pod 0.4.2. The
other pre-existing versioned files are unchanged.
* (Basics.pod) Small updates to the ROUTINES main section.
* (Core.pod, Grammar.pod, PerlHosted.pod) Added 4 new trivial data
type definitions 'sys.Core.(|Quasi)(Tuple|Relation).D0', some of which
were previously referenced but not defined; also corrected any
references that said 'D0C(0|1)' to just say'D0'.
* (Core.pod) Added new pseudo-type sys.Core.Some.ScaTupRel, which is
essentially a union type over Scalar|Tuple|Relation; it is for tersely
refering to the general type of a scalar|tuple|relation attribute.
* (Core.pod) Added 3 new Int functions, 'increase' and 'decrease'
(meaning '++' and '--'), and 'factorial'.
* (Core.pod) Added 2 new Tuple functions 'attr_from_Tuple' and
'Tuple_from_attr', which work with degree-one tuples; they are
analogous to the 2 "(T|R) from (R|T)" Relation functions that work with
cardinality-one relations. Also added 2 new Tuple functions 'attr' and
'update_attr', which read or write an attribute in an arbitrary tuple.
* (Core.pod) Added new Relation function 'power_set', which results in
a Set of all subsets of its Relation argument (which could itself be
just a Set). (Note: Not sure whether or not this is actually useful.)
* (Core.pod) Added descriptions to the Relation functions
group|ungroup, updated those of tuple wrap|unwrap. Added 3 new
complementary tuple|relation functions cmpl_wrap|cmpl_group.
* (Core.pod) Fleshed out the Relation function 'substitution', and
added 2 new relational functions,
'substitution_in_(restriction|semijoin)'. While 'substitution' will
transform all tuples unconditionally, the 2 new 'in' functions let one
keep the substitutions within a subset of the tuples.
* (Core.pod) Added new Relation function 'map', which provides a
convenient one-place generalization of per-tuple transformations that
otherwise might require the chaining of up to a half-dozen other
operators like restriction, extension, and rename; like Perl's "map",
or SQL's generic select-list.
* (Core.pod) Fleshed out the Relation function 'summary', giving it a
full parameter list and description. Note that this function is only
intended to be used in situations where the corresponding SQL would
involve a GROUP BY, and there is to be one result tuple per group,
which also means an empty result relation from an empty input relation.
Those who want their summary to be one tuple for the entire input, even
an empty one, would just invoke the N-adic / aggregate operators
directly without doing it by way of 'summary'.
* (Core.pod) Added 2 new Relation functions 'is_(|not_)proper_subset'.
* (Core.pod) Added initial complement of 6 Set-specific functions:
'is_member', 'is_not_member', 'insertion', 'deletion', 'Set_from_wrap',
'Set_from_attr'. The first 4 are just short-hands for their Relation
counterparts, having tuple attribute values as parameters rather than
whole tuples. The 'Set_from_attr' is intended to be the most
convenient way to pull out values from an attribute for feeding to an
aggregate function; it is short-hand for simple relational operations.
The 'Set_from_wrap' ought to be convenient for other reasons, or if not
then its counterparts under Bag or Seq perhaps will be.
* (Core.pod) Added initial complement of 2 Maybe-specific functions:
'attr_or_default', 'attr_or_value'. They are intended to be like
Perl's defined-or functions, resulting in their only/main argument's
content if it isn't empty, or a default value / second argument if it
is; alternately these are like SQL's 2-argument COALESCE or NVL or
IF_NULL etc; these should be useful in defining outer-joins.
* (Core.pod) Added initial complement of 17 Bag-specific functions:
'is_member', 'is_not_member', 'insertion', 'deletion', 'Bag_from_wrap',
'Bag_from_attr', 'cardinality', 'is_subset', 'is_not_subset',
'is_proper_subset', 'is_not_proper_subset', 'union', 'intersection',
'difference', 'count', 'Set_from_Bag', 'Bag_from_Set'. The first 6 are
as per the 6 set-specific functions. The next 8 are as per the
same-named Relation functions but that they have special semantics that
take > 1 multiplicity of values into account; the Relation ones work as
is for Set, but not as typically desired for Bag. Then 'count' says
how many occurrances (which may be zero) of a value are in a Bag. The
last 2 are short-hands for moving data between Set and Bag types.
* (Core.pod) Other minor updates.
2007-12-09 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.13.0 is released on CPAN as
Language-MuldisD-0.13.0.tar.gz.
* As of this release, the in-code $VERSION declarations of all Perl 5
packages in this distribution are changed to match the X.Y.Z format
that the same packages' own VERSION POD had all along (the old in-code
format was X.00Y00Z). A consequence of this change is that this
distribution has gained an external dependency on the Perl 5 module
'version', which is not bundled with Perl 5.8.x; however, it *is*
bundled with Perl 5.10.x, so if you are using that newer Perl, you
won't have to install 'version' separately from CPAN.
* New file versions are: MuldisD.pm 0.13.0 and Core.pod 0.11.0. The
other pre-existing versioned files are unchanged.
* (Core.pod) Renamed some tuple|relation functions so they describe
the function's result rather than its action, or are otherwise more
improved; that is, they are less verbs and more nouns or adjectives:
'exists' => 'is_member', 'insert' => 'insertion', 'delete' =>
'deletion', 'evacuate' => 'empty', 'project' => 'projection', 'remove'
=> 'cmpl_projection', 'tclose' => 'transitive_closure', 'restrict' =>
'restriction', 'extend' => 'extension', 'summarize' => 'summary',
'substitute' => 'substitution', 'compose' => 'composition'. Also
renamed the enumerated value Cat.E_TDM:restrict to
Cat.E_TDM:restriction. Also added 2 new complementary functions
sys.Core.Relation.(is_not_member|cmpl_restriction), and added
sys.Core.Relation.universal to go with sys.Core.Relation.empty.
* (Core.pod) Renamed some blob|text functions: 'catenate' =>
'catenation', 'fold_case_to_(upper|lower)' =>
'case_folded_to_(upper|lower)', 'trim_whitespace' =>
'whitespace_trimmed'. Also renamed some ordered functions:
'(|reverse_)compare' => '(|reverse_)comparison'.
2007-11-23 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.12.0 is released on CPAN as
Language-MuldisD-0.12.0.tar.gz.
* New file versions are: MuldisD.pm 0.12.0 and Basics.pod 0.10.1 and
Core.pod 0.10.0. The other pre-existing versioned files are unchanged.
* (Core.pod) Added new core functions Ordered.is_(in|out)side_range,
which provide generic range checking for any Ordered subtype.
* (Core.pod) Renamed the 2 functions (Blob|Text).contains each to
.is_substr, and renamed Relation.contains to .is_subset; also added 3
new functions that are 'is_not' variants of the first 3.
* (Core.pod) Added new enumerated type Cat.E_RM (rounding
method), and then merged the 5 old specialized functions
Rat.round_(half_up|to_(even|floor|ceiling|zero)) into the 1 new generic
function Rat.Int_from_Rat, whose second parameter is of the new type;
also renamed Rat.rebase to Rat.round.
* (Core.pod) Added new ternary tuple type Cat.RatRoundRule which
defines a controlled coercion of a real number into a rational number
having a specific radix and precision. (Also added new type
Int.PInt2_N, an integer > 1, which supports it.) Then refactored the 4
functions Rat.(round|log|natural_(power|log)) to have 1 parameter of
the new tuple type rather than 3 round-guiding parameters.
* (Basics.pod, Core.pod) Small typo fixes.
2007-11-19 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.11.0 is released on CPAN as
Language-MuldisD-0.11.0.tar.gz.
* New file versions are: MuldisD.pm 0.11.0 and Basics.pod 0.10.0. The
other pre-existing versioned files are unchanged.
* (Basics.pod) Updated multiple sections to indicate express support
for multi-threading within Muldis D virtual machines, where the
transaction trees of the in-DBMS processes are mutually autonomous, but
synchronized by the DBMS when they use the same depots. Updated
sections were mainly ENVIRONMENT, and TRANSACTIONS AND CONCURRENCY, and
RESOURCE MODULARITY AND PERSISTENCE, and ENTITY NAMES. The top level
entity namespace 'fed' is now specifically the depot mounts by a single
in-DBMS process, not all depot mounts in the whole DBMS.
2007-11-08 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.10.0 is released on CPAN as
Language-MuldisD-0.10.0.tar.gz.
* New file versions are: MuldisD.pm 0.10.0 and Core.pod 0.9.2 and
Basics.pod 0.9.0 and Grammar.pod 0.7.1 and PerlHosted.pod 0.4.1. The
other pre-existing versioned files are unchanged.
* (MuldisD.pm) Updated the DESCRIPTION to mention Muldis D in
retrospect having some designs in common with FoxPro or xBase.
* (Basics.pod) Added a TERMINOLOGY item for "universal" to specify
that Muldis D does not allow sets to be members of themselves, and more
generally that no type or value definitions may be recursive; so
"universal" is only the common superset of sets that these rules allow;
some philosophers may say that it is possible for sets to have
themselves as members, so this update specifies that Muldis D does not.
* (Basics.pod) Updated the 'main' routine kind to specify that it can
not see or update any global variables, which now leaves
'(|inner_)procedure' as the only kind that can; also that 'main' should
just be loading/invoking depots, where all other user-defined code is.
* (Basics.pod) Added new RESOURCE MODULARITY AND PERSISTENCE main
section. Removed the whole concept of user-defined entities being
allowed to exist outside of depots; now all user-defined entities must
exist in depots. Also, the conceptual role of depots has been expanded
to cover general user code libraries, and are not mainly just for data.
Also, all user-defined relvars|types|invokable-routines now live in
packages, rather than users having the choice for them to be in or out;
but package members can also be public, so no actual choice is lost.
* (Basics.pod) Updated ENTITY NAMES; removed the 'app' top namespace.
* (Basics.pod) Updated ENTITY NAMES to add the 'imp' top level
namespace, which is like 'sys' in purpose but that while 'sys' is just
for types and routines that are defined by the standard Muldis D
specification, 'imp' is for other, non-standard types and routines that
a Muldis D implementation has added, and which are specific to that
implementation. Also added is the new relcon namespace 'cat.impl',
which is to 'imp' what 'cat.system' is to 'sys'. It is expected that
the catalog relvars under cat.(mount|foreign|interp), whose structures
were already expected to be implementation-specific, would likely need
to be defined in terms of (typically named nonscalar) data types that
are also implementation-specific, and so those are invokable under
'imp'. Besides that main intended purpose of 'imp', a Muldis D
implementation that wants to embrace and extend Muldis D with further
types and routines intended for user data, should declare them there.
* (Basics.pod, Grammar.pod, PerlHosted.pod) Updated ENTITY NAMES, and
other references, to rename the 'glo' (global) top-level entity
namespace to 'fed' (federation), for better accuracy; likewise, renamed
the 'sch' (schema) top-level namespace to 'sdp' (subdepot).
* (Basics.pod) Fleshed out ENTITY NAMES with new documentation
subsections that describe the various name spaces, and interpretation.
* (Core.pod) Added comment to Relation.Set mentioning that a set type
is essentially the power set of the type of its 'value' attribute.
2007-10-11 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.9.1 is released on CPAN as
Language-MuldisD-0.9.1.tar.gz.
* New file versions are: MuldisD.pm and Core.pod 0.9.1. The other
pre-existing versioned files are unchanged.
* (Core.pod) Each main type declaration now had its own level-2
heading rather than it being a bullet-list item.
* Fleshed out the tail of this Changes file with a summary pre-release
(rel. 2007 June) history of Muldis D; going from mid-2002 to mid-2007.
2007-10-09 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.9.0 is released on CPAN as
Language-MuldisD-0.9.0.tar.gz.
* New file versions are: MuldisD.pm and Core.pod 0.9.0 and Basics.pod
0.8.0 and Grammar.pod 0.7.0 and PerlHosted.pod 0.4.0. The other
pre-existing versioned files are unchanged.
* (MuldisD.pm, Grammar.pod, PerlHosted.pod) Added a paragraph to the
DESCRIPTION of MuldisD.pm that gives the fully-qualified name of the
official/original (not embraced and extended) Muldis D language spec
that this distro represents, and gives instructions for people to
change at least its authority portion of the name if they release their
own modifications to the language spec, and instructs for Muldis D code
to embed the long name of the spec they are written to. In Grammar.pod
and PerlHosted.pod, updated their formats for specifying the language
long name they conform to; in both cases, the root token or PHMD node
is now a simple sequence of these 4 parts: 'MuldisD', the authority
string, the version number, and the payload; PerlHosted.pod also gives
an alternative 3 parts version for up-front VM config, rather than
repeating it with every payload later.
* (Basics.pod) Overhauled what kinds of Muldis D routines there are,
and consequences thereof; the largest updates were to the ROUTINES
section. A hierarchical diagram was added to ROUTINES to group the
kinds by similarity. The 3 kinds function|update_operator|procedure
gained inner_\w+ counterparts, which are the same but soley live within
and comprise the definitions of other routines, while the initial 3 are
now strictly not so. All kinds of constraint routines are now pure
deterministic functions (that don't see globals), like just the
type_constraint used to be, which is fine since entire databases are
defined as being types or variables (so now only procedure|main can see
globals). The distinct state_constraint is now gone, merged into
type_constraint, each of which is tied to a data type definition and
runs at value selection time. Now, a transition_constraint is tied to
a variable and runs when it is updated, it has 2 arguments holding the
before|after state. Updated ENTITY NAMES to split the 'lex' namespace
into itself and 'inn', the latter being used to invoke inner routines,
and the former being just for true lexicals. Also updated TRANSACTIONS
AND CONCURRENCY.
* (Basics.pod, Core.pod) In Core.pod, added a new SYSTEM-DEFINED CORE
PROCEDURES section, and its first 2 entries,
sys.Core.Control.(fail|try_catch), the use of which is now how you
generally do explicit transactions; appropriate parts of Basics.pod
were updated to mention/explain this.
* (Core.pod) Renamed the operator sys.Core.Relation.not to
sys.Core.Relation.negation, for better symmetry with other set ops.
* (Basics.pod) Updated the TYPE SYSTEM section to add a new main type
category called "remnant types", which is composed of all types that
don't qualify as a type of the previous 5 categories. Generally
speaking, a remnant type is the declared type of each attribute of a
quasi-nonscalar type, when said attribute isn't one of the special
system-defined maximal types. Also added the concepts of "exclusion"
types and "negation" types to complement the 3 existing concepts of
union|intersection|difference types.
* (Core.pod, Grammar.pod, PerlHosted.pod) Renamed the catalog data
types 'Cat.ShortName' and 'Cat.LongName' to 'Cat.Name' and
'Cat.NameChain' respectively, and updated their definitions; a Cat.Name
must now be a non-empty string, Cat.NameChain parts must be likewise,
and updated the escaping rules for the latter. In Core.pod, updated
their documentation, and added 2 more types 'Cat.NESeqOfName' and
'Cat.FlattenedNameChain' which now are part of the definition of
'Cat.NameChain'. In Grammar.pod, updated the grammar concerning entity
names so they are treated differently than text data; also added
examples of both to EXAMPLES. In PerlHosted.pod, added for the first
time definitions of Cat.Name and Cat.NameChain PHMD nodes, as the new
section CATALOG SCALAR VALUES; also, "type name" portions of older PHMD
nodes now can take both payload formats of Cat.NameChain nodes. Also
in Core.pod, renamed any other types having 'ShortName' to remove the
'Short'.
* (Core.pod) Added new catalog data type Cat.Type plus new supporting
types: Cat.E_TK, Cat.E_TDM, Cat.NameTypeMap, Cat.SetOfSetOfName,
Cat.SetOfNameChain.
* (Core.pod) Added new data type 'Cat.Exception' which holds the
details of a thrown exception, but it lacks a description for now.
* (Basics.pod) Removed the CATALOGS main section, and the "Temp Old
Entity Names Docs" subsection of ENTITY NAMES; these texts were very
out of date and will be replaced later.
2007-09-23 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.8.1 is released on CPAN as
Language-MuldisD-0.8.1.tar.gz.
* From now on, the file version of MuldisD.pm will be kept in sync with
the distribution version, regardless of whether that file had otherwise
been changed since the previous release.
* New file versions are: MuldisD.pm and Core.pod 0.8.1 and Grammar.pod
0.6.1 and PerlHosted.pod 0.3.1. The other pre-existing versioned files
are unchanged.
* (Core.pod, Grammar.pod, PerlHosted.pod) Made various minor
documentation bug-fixes or updates.
* (Core.pod) Updated the SYSTEM-DEFINED CORE SCALAR FUNCTIONS sections
for enumerated types to consolidate the per-value selector function
documentation for brevity; the functions themselves were unchanged.
* (Core.pod) Updated all the system-defined function signatures to
remove the 'RO:' text by parameters; that text was superfluous because
all parameters of all functions are always read-only. The 'UPD:' and
'RO:' text in system-defined procedure signatures remains, since a
procedure can have either/both subject-to-update or read-only params.
2007-09-22 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.8.0 is released on CPAN as
Language-MuldisD-0.8.0.tar.gz.
* New file versions are: Core.pod 0.8.0 and Basics.pod 0.7.0 and
Temporal.pod and Spatial.pod 0.5.1 and MuldisD.pm 0.5.0 and SeeAlso.pod
0.3.2 and PerlHosted.pod 0.3.0. The other pre-existing versioned files
are unchanged.
* (MuldisD.pm, Basics.pod) Updates to various main/introductory
documentation. Changed the NAME of Basics.pod to "10,000 Mile View of
Muldis D" from "Design document of the Muldis D language" as it isn't
the intro file anymore (MuldisD.pm is instead). Moved the large
PREFACE and DESCRIPTION sections from Basics.pod to MuldisD.pm, then
did a small amount of editing to them; Basics.pod then gained small
replacements. Further minor edits to other sections.
* (Core.pod, PerlHosted.pod, Temporal.pod, Spatial.pod) More
system-defined package consolidation: Empty merged into Universal;
Database merged into Tuple; (Set|Maybe|Seq|Bag) merged into Relation;
Quasi(Set|Maybe|Seq|Bag) merged into QuasiRelation.
* (Basics.pod) Added indenting to the ENTITY NAMES hierarchy.
* (Core.pod) Moved the documentation sections about non-catalog
specialized subtypes below their counterpart sections on catalog types.
* (Core.pod) Renamed the data types Cat.(ShortNameSet|AttrRenameMap)
to Cat.(SetOfShortName|BiDiShortNameMap); the latter's attributes were
also renamed.
* (Core.pod) Fleshed out the set of catalog data types by adding these
new ones: Cat.ScalarLiteral, Cat.E_EK, Cat.Expr, Cat.ShortNameMap,
Cat.SetOfShortNameMap.
* (SeeAlso.pod) Reflected that Muldis DB is now LGPL rather than GPL.
2007-09-11 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.7.0 is released on CPAN as
Language-MuldisD-0.7.0.tar.gz.
* Removed the file Catalog.pod, after moving its main content into the
files Basics.pod and Core.pod, and removed any references to
Catalog.pod in other files. The CATALOGS documentation section was
moved into Basics.pod, below ENTITY NAMES. The TYPE SUMMARY section
was merged into its counterpart in Core.pod. The 2 SYSTEM-DEFINED CORE
CATALOG (|NON-)SCALAR DATA TYPES sections were moved into Core.pod, at
the end of all the type definitions.
* New file versions are: Core.pod 0.7.0 and Basics.pod and Grammar.pod
0.6.0 and Temporal.pod and Spatial.pod 0.5.0 and PerlHosted.pod 0.2.0.
The other pre-existing versioned files are unchanged.
* (Basics.pod) Chopped the 'main' routine kind down so that it is now
only applicable to a non-hosted Muldis D application; hosted (eg, by
Perl) Muldis D programs don't have 'main' Muldis D routines.
* (Basics.pod, Core.pod) Changed the database type so its attributes
may now be composed of not only relations, but databases (the leaves of
this recursion are all relations); the reason for this was to provide a
more elegant way to represent the common convention of dividing a
relational database into schemas for better entity management.
* (Basics.pod) Started rewrite of the ENTITY NAMES documentation; for
now there is just the addition of a new namespace hierarchy. The new
hierarchy has the following 8 top-level names: cat, sys, app, glo, dep,
sch, pkg, lex. The old namespaces map to the new ones as follows:
sys.cat -> cat.system ; nat.cat -> cat.native ; mnt -> cat.mount ;
foreign -> cat.foreign ; interp -> cat.interp ; sys.(type|rtn).* ->
sys.(Core|<extension>).<package>.* ; nat.(data|type|rtn).* ->
(app|glo.<depot>).* ; lex.* -> lex.* . The top-level names [dep, sch,
pkg] are context-sensitive aliases for something under 'app' and/or
'glo', so entities can tersely and portably refer to their own
depot|schema|package, sort of like 'lex' (lexical) allows. Notably,
the type of entity, data|type|rtn, is no longer included in the long
name of most entities, and entities of different types now clearly
share the same namespace, as per is typical with SQL DBMSs where both
tables and stored procedures are in the same schema object namespaces.
* (Core.pod, Grammar.pod, PerlHosted.pod, Temporal.pod, Spatial.pod)
Renamed all the system-defined types and operators to roughly fit into
the new namespace hierarchy. The operators saw less drastic changes,
as roughly speaking, their 'rtn' name component was simply changed to
'Core' (it would have been different for temporal/spatial operators,
but none of those were defined yet). The types saw more drastic
changes; roughly speaking, all 'type' were renamed to one of
Core|Temporal|Spatial, and for non-catalog core types, the unique part
of each name was replaced with 2 instances of itself. Roughly
speaking, what used to be a type name now doubles as a type name and a
package name for both that type and for its operators. Following this,
the new system-defined packages were then either consolidated or split
as appropriate, grouping most similar entities and separating less
similar ones. For example, all generic 'Int' types were grouped under
one package, and the 'Temporal' types were split into several.
* (Grammar.pod, PerlHosted.pod) Updated the example user-defined
entity names so that they roughly fit into the new namespace hierarchy.
What was nat.type.* is now glo.the_db.*.
2007-09-03 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.6.0 is released on CPAN as
Language-MuldisD-0.6.0.tar.gz.
* New file versions are: Core.pod 0.6.0 and Basics.pod 0.5.1 and
Grammar.pod 0.5.0 and Temporal.pod 0.4.1 and Spatial.pod 0.4.0 and
Catalog.pod 0.3.1 and PerlHosted.pod 0.1.0. The other pre-existing
versioned files are unchanged.
* (Core.pod, Basics.pod, Catalog.pod, Temporal.pod, Spatial.pod)
Renamed the union type Ordinal to Ordered, and any types previously
referred to as being ordinal types are now referred to as being ordered
types. This change makes things more correct (and less confusing),
since actual ordinal types are supposed to be both finite and discrete,
whereas some Muldis D ordered types are infinite and/or continuous.
* (Core.pod) Removed the floating-point numeric types from the core
again, but that they aren't yet re-added to some language extension;
they will be later, as per inexact or significant-figure-watching
numerics in general. Now the core just contains exact numerics that
are integers or rationals (and generally speaking it will now be said
exact types specifically which some common language extensions like
temporals or spatials are generally built over). This simplifying
change was made because it is expected that most general uses of
numerics in Muldis D program code will not use numbers in the extreme
ranges that only inexact floats can represent efficiently (eg, 10^308),
and rather they will likely just have numbers of less than 20-30
digits, which are easy enough for rationals.
* (Core.pod) Updated the Rat|BRat|DRat type definitions slightly.
* (Core.pod) Added the URat|PRat types, which are to Rat what
UInt|PInt are to Int. Also added (Set|Maybe|Seq|Bag)OfRat types.
* (Core.pod) Added new Int operators range|median|mode, updated the
Int operator 'power', moved the definition of 'abs' upward.
* (Core.pod) Added an initial complement of 28 Rat operators, which
are mostly a superset of analogies to the Int operators (minus
'remainder'); additions include operators for calculating
means/averages, logarithms, and rounding.
* (Grammar.pod, PerlHosted.pod) Added sections for the Rat|URat|PRat
types as per for Int|UInt|PInt.
* (Spatial.pod) Added an initial hierarchy of 15 spatial types, but
as yet they lack descriptions.
2007-08-31 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.5.0 is released on CPAN as
Language-MuldisD-0.5.0.tar.gz.
* The rational numeric and floating-point numeric data types have been
promoted to the language core, and so the main content of Num.pod was
moved into Core.pod, under the TYPE SUMMARY and SYSTEM-DEFINED CORE
SCALAR DATA TYPES sections; the rest of the file Num.pod was then
deleted, and any references to it in other files were removed. The
promoted data types were also renamed to remove the '.Num'.
* New file versions are: Basics.pod and Core.pod 0.5.0 and Grammar.pod
0.4.1. The other pre-existing versioned files are unchanged.
* (Basics.pod) Reorganized the entity namespace 'lex.*' so it no
longer mirrors the structure of the (global) 'nat.*' namespace. There
are no longer any lexically scoped data types or routines or special
catalog variables; only normal variables can be lexical.
* (Basics.pod) Updated the definition of the 'function' routine kind
so it has no lexical variables, consists of a single expression tree,
and can only invoke functions; hence a function is now just a named
expression tree. Replaced the 'host_gate' routine type with the 'main'
routine type, as it is conceptually the non-invokable "main program" of
a Muldis D program.
* (Core.pod) Added a bunch of named core data subtypes that exist for
convenience, such as because they name many core operator parameter
types. Added a tree of these to the TYPE SUMMARY section, and added a
new SYSTEM-DEFINED CORE SPECIALIZED SUBTYPES section. For example,
many of these additions are named
'sys.type.(Set|Maybe|Seq|Bag)Of(Bool|Int|Blob|Text)'. The pre-existing
'sys.type.PInt2_36' type was also moved into these sections.
* (Core.pod) Rearranged the documentation sections for operators, so
that they are all grouped first by routine kind and second by the
mainly applicable data type, rather than the reverse grouping; all
functions appear first (the vast majority), then all update operators
(a minority), then all system services (a smaller minority.
* (Core.pod) Renamed many 'v' function parameters to 'topic'.
* (Core.pod) Updated the 2 int-text mapping function signatures to
rename any 'Text' to 'NEText'. Merged and generalized the 4 blob-text
mapping functions into 2 which lack '_(2|16)' suffixes. Added
'maybe_*' variants of the 2 functions 'Int.(quotient|remainder)'.
* (Core.pod) Removed the 'Rat' subtype 'RatI' and renamed its sibling
subtypes to '(B|D)Rat' from 'Rat(B|D)'.
* (Core.pod) Replaced the 2 'FloatB(32|64)' data types with the more
generic 'Float' type, then gave that 2 new subtypes of '(B|D)Float' as
per the 'Rat' type hierarchy. The new 'Float' type is an exact numeric
of unlimited precision as per 'Int' and 'Rat', and it doesn't have any
special values like a +/- zero distinction, nor infinities, nor NaNs.
Note that all Muldis D core numeric types are exact and lack special
values; any numerics that are inexact or have special values will be
relegated to language extensions; in the core, any precision loss that
could possibly happen in an operation (eg, from a square-root) is part
of the defintion of operators, not the data type.
* (Core.pod) Replaced the function 'Tuple.extend' with
'Tuple.product'; the latter is also fleshed out.
* (Core.pod) Fleshed out the definitions of these functions:
'Relation.quotient' (also renamed from 'divide'), 'Relation.restrict',
'Relation.extend'. Also added these functions: 'Relation.product'.
* (Grammar.pod) Changed the tokens 'Cat(Short|Long)Name' to
'Cat.(Short|Long)Name' so they match actual type names like the rest of
Grammar.pod does.
2007-08-12 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.4.1 is released on CPAN as
Language-MuldisD-0.4.1.tar.gz.
* New file versions are: PerlHosted.pod 0.0.1. The other pre-existing
versioned files are unchanged.
* (PerlHosted.pod) This release is an experiment with an alternate
formatting of the POD list items, in an attempt to make them look more
like actual lists under the Search CPAN site, rather than paragraphs;
each "=item Foo" is now spelled "=item *\rFoo".
2007-08-09 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.4.0 is released on CPAN as
Language-MuldisD-0.4.0.tar.gz.
* Renamed MuldisD.pod to MuldisD.pm, and added an empty dummy package
declaration of Language::MuldisD to it, all for the sole purpose of
helping the CPAN indexer link to this distribution properly; it doesn't
work when the namespace file is plain pod. For similar reasons, the
version number of MuldisD.pm will now always be kept in sync with the
whole-distribution version number declared in the Makefile.PL.
* Also renamed Language.pod to Basics.pod.
* New file versions are: MuldisD.pm and Basics.pod and Core.pod and
Grammar.pod and Num.pod and Temporal.pod 0.4.0. The other pre-existing
versioned files are unchanged.
* (Basics.pod) Introduced complete vs parameterized types.
* (Basics.pod) Every data type is now named and is referred to by that
name, the change being that only scalar types used to have names. This
said, the actual identities of types haven't changed, so 2
differently-named declarations of types that aren't scalar and have the
same structure will still be considered to be the same actual type; the
names for types that aren't scalars are simply aliases for this
identity. This change was made to greatly simplify (and reduce errors
in) the process of declaring data types, particularly hierarchical
types, and declaring nonscalar values.
* (Core.pod) Added new operators
Universal.(is_value_of_type|treat|default).
* (Core.pod) Renamed each of the operators Universal.(equal|not_equal)
and Relation.(empty|not_empty) to prepend an "is_".
* (Core.pod, Num.pod, Temporal.pod) Updated each of the ordinal data
types to specify what their minimum and maximum values are, or whether
said are infinities.
* (Core.pod) Redefined the Maybe-returning N-adic functions
Ordinal.(min|max) with versions that instead try to return that
functions' identity value when given zero argument values, and
fails/dies in just specific situations where said identity is
impossibly or impractically large to handle. Also added 2 new
functions Ordinal.maybe_(min|max) that provide the old behaviour.
* (Core.pod) Redefined the N-adic functions Blob.(and|or|xor) from
resulting in Maybes to resulting in identity values on zero inputs.
Also corrected the Relation.intersection function definition such that
its identity value is actually the universal relation for its heading,
not the empty relation; depending how big that is, the function may now
possibly fail on zero input values. Also added new function
Relation.not, which results in its argument subtracted from the
universal relation for the same heading; this may possibly fail if that
is too big a value.
* (Temporal.pod) Restricted the Temporal.Duration(|OfDays) types to be
specific to data with time zone offsets, and added 2 more types
Temporal.Duration(|OfDays)NoTZ to handle the other possibility; the
idea is that the former should be considered more accurate than the
latter, as per DateTime vs DateTimeNoTZ. Also updated all 4 to permit
negative durations in addition to positive ones. Also rearranged the
types to group all the with-timezone and no-timezone together.
* (Grammar.pod) Rewrote the representative Concrete Muldis D grammar
so that it is formatted as an actual compiling (though otherwise
untested) Perl 6 grammar, rather than the pseudo-LALR grammar. Also,
the rewritten grammar is actually complete, unlike the many "todo" gaps
in the old. Not that it won't stand to be further improved later.
* (Grammar.pod) Added new EXAMPLES documentation section which shows
actual Concrete Muldis D code fragments.
* Added new file lib/Language/MuldisD/PerlHosted.pod, which starts at
version 0.0.0. This file parallels Grammar.pod, but instead shows what
arrangement of core Perl data structures make up Perl hosted Abstract
Muldis D, which is the recommended interchange format between Muldis D
implementations and Perl applications. With code examples! This file
also stands as a recommendation for a general AST for use by database
related modules, such as ORMs, to specify database queries with.
2007-07-24 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.3.1 is released on CPAN as
Language-MuldisD-0.3.1.tar.gz.
* New file versions are: Language.pod and SeeAlso.pod 0.3.1. The other
versioned files are unchanged at 0.3.0.
* Fixed a bug where both MuldisD.pod and Language.pod had the same
NAME, which resulted in CPAN indexing problems.
* Minor fix in SeeAlso.pod.
2007-07-24 Darren Duncan <darren@DarrenDuncan.net>
* Language::MuldisD version 0.3.0 is released on CPAN as
Language-MuldisD-0.3.0.tar.gz.
* What was Muldis-DB at version 0.2.0 and earlier, has been split in 2,
with the parts to be Language-MuldisD and Muldis-DB, each at version
0.3.0 and later. Prior to the split, both the Perl 5 and Perl 6
versions of Muldis-DB contained identical copies of what became
Language-MuldisD; after the split, neither Muldis-D had a copy.
* All versioned files had their version numbers brought up to 0.3.0.
* This is the first release of the Language-MuldisD distribution, and
the first release of any distribution to contain Perl 5 modules named
Language::MuldisD::\w+.
* The file lib/Language/MuldisD.pod is cloned from part of what used to
be lib/Muldis/DB.pm, and the file lib/Language/MuldisD/SeeAlso.pod is
cloned from part of what used to be lib/Muldis/DB/SeeAlso.pod, and
lib/Language/MuldisD/Language.pod was renamed from
lib/Muldis/DB/Language.pod, and all other lib/Language/MuldisD/\w+ were
renamed from lib/Muldis/DB/Language/\w+.
* Updated Grammar.pod concerning '(Int|Blob):x:y' so that the 'x' is
now a single character in the same base as the 'y', rather than being a
possibly multi-character integer in base-10; moreover, the 'x' is now
equal to the highest value that a character may represent, which in the
base in question is 1 less than the base number. So eg, base-2 is now
specified with an 'x' value of '1', base-10 is a '9', base-16 an 'F',
etc. Also, the 'y' part for Int|Blob is no longer quote-delimited.
* This is the Language-MuldisD-0.3.0 file manifest:
Changes
INSTALL
lib/Language/MuldisD.pod
lib/Language/MuldisD/Catalog.pod
lib/Language/MuldisD/Core.pod
lib/Language/MuldisD/Ext/Num.pod
lib/Language/MuldisD/Ext/Spatial.pod
lib/Language/MuldisD/Ext/Temporal.pod
lib/Language/MuldisD/Grammar.pod
lib/Language/MuldisD/Language.pod
lib/Language/MuldisD/SeeAlso.pod
LICENSE/GPL
Makefile.PL
MANIFEST
MANIFEST.SKIP
META.yml
README
t/LMD_00_Compile.t
TODO
2007-07-22 Darren Duncan <darren@DarrenDuncan.net>
The next version of the Module List will list the following module:
modid: Language::MuldisD
DSLIP: cmong
description: Formal spec of Muldis D relational DBMS lang
userid: DUNCAND (Darren Duncan)
chapterid: 7 (Database_Interfaces)
enteredby: ADAMK (Adam Kennedy)
enteredon: Mon Jul 23 04:56:26 2007 GMT
The resulting entry will be:
Language::
::MuldisD cmong Formal spec of Muldis D relational DBMS lang DUNCAND
2007-07-20 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::DB version 0.2.0 for Perl 5 is released on CPAN as
Muldis-DB-0.2.0.tar.gz. The rest of this Changes entry refers only to
the portions of it that became part of the Language-MuldisD
distribution following release 0.2.0.
* New file versions are: DB.pod and Language.pod and Core.pod and
Catalog.pod and Grammar.pod and SeeAlso.pod 0.2.0. Unchanged file
versions are: Num.pod and Temporal.pod and Spatial.pod 0.1.0.
* Updated the TRANSACTIONS AND CONCURRENCY section of Language.pod in
regards to how the scope of explicit transactions is specified, and
where implicit transactions occur. Also, Muldis D now no longer has
language for non-scope-attached transactions, and any concept of
distinct transaction initiation or termination statements will be
hoisted to the host language (presumably as methods of ::DBMS objects).
* Updated Core.pod to add the scalar type 'PInt2_36', and to replace
the pseudo-type 'Any' with the pseudo-type 'Some.Universal', and added
'Some.Ordinal'.
* Updated Grammar.pod concerning integer literals; they can be
represented with any of base-2 thru base-36 now.
* Updated Grammar.pod and Core.pod concerning enumerated types, such as
Bool and Order; individual values are now specified using eg
[Bool:true] rather than [Bool.True], which then makes them more like
literals of other simple types, and less like data type names.
* Updated Core.pod to add definitions for the generic operators common
to all ordinal types: compare, reverse_compare, is_increase,
is_decrease, min, max. Added 'reverse' operator for the Order type.
Added or replaced a bunch of operators for the Int|Blob|Text types.
Other small changes.
* Updated Core.pod to add an initial complement of common tuple and
relation operators (such as project, join, union), perhaps most of
them. These are a large part of what makes Muldis D a relational
language at all.
* Updated Catalog.pod to add new core data types: Cat.ShortNameSet,
Cat.AttrRenameMap.
2007-07-11 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::DB version 0.1.0 for Perl 5 is released on CPAN as
Muldis-DB-0.1.0.tar.gz. The rest of this Changes entry refers only to
the portions of it that became part of the Language-MuldisD
distribution following release 0.2.0.
* This is a major release that focuses on overhauling or defining part
of the Muldis D meta-model / system catalog, which is essential for
supporting any user-defined DBMS entities, that is, for doing anything
remotely useful. Said overhaul is expected to be staged over 3-4
consecutive releases, of which the current one is essentially just
updating documentation; not much code was changed by this release.
* As of this release, all pod-only files now also have version numbers,
shown in the VERSION docs by NAME, like code-containing modules do; the
initial version numbers are all 0.1.0.
* Muldis D now has 2 representation formats (Concrete Muldis D,
Abstract Muldis D) rather than 3 (relations, ASTs, strings).
* Rearranged any relevant docs so that the most important core scalar
types are now in the order [Bool, Int, Blob, Text] and the relation
type factory Maybe now appears after Set.
* Muldis D now has a new scalar data type, "Order", which is an
enumeration (like "Bool" is) of 3 values: [Increase, Same, Decrease];
it is the result type of any dyadic comparison operator that underlies
the likes of less|greater-than or min|max or sorting operations.
* Muldis D now has the new scalar types "Cat.ShortName" and
"Cat.LongName", which replace the also removed "Cat.EntityName" and its
(as yet unused) system-defined subtypes.
* Split up Language.pod 6 ways, into itself and
Language/(Core|Catalog).pod and
Language/Ext/(Num|Temporal|Spatial).pod. For the most part, the only
initial content of the 5 new files are corresponding portions of what
used to be the SYSTEM-DEFINED DATA TYPES and (actually empty)
SYSTEM-DEFINED ROUTINES main documentation sections of Language.pod,
but that the CATALOGS main section was also moved to Catalog.pod;
Language.pod retained all the other documentation sections that it
previously had. (Language.pod retained about 75% of its previous
content; about 25% was moved out.)
* Further updated the 5 language files with type definitions, to update
some definitions, and also to add a small TYPE SUMMARY main doc section
to each file.
* Updated Core.pod to add several main doc sections that have an
initial complement of system-defined routines. In particular, the
equal|not_equal|assign routines that all types have are now defined,
and all the common boolean and integer operators were added, and some
converter routines such as int-from-text et al, were all added. Many
other operator definitions are pending, especially the relational ones.
* Added new file lib/Muldis/DB/Language/Grammar.pod, which describes
Concrete Muldis D details that aren't applicable to Abstract Muldis D.
2007-06-29 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::DB version 0.0.1 for Perl 5 is released on CPAN as
Muldis-DB-0.0.1.tar.gz. The rest of this Changes entry refers only to
the portions of it that became part of the Language-MuldisD
distribution following release 0.2.0.
* New file versions (not marked though) are: Language.pod 0.0.1.
* The primary purpose of this release is to re-license the Muldis D
specification under actual free software licenses, specifically version
3 of the GPL family of licenses, which the Free Software Foundation
formally published on 2007 June 29th. By contrast, the previous Muldis
D releases were under an expiring proprietary license, with just the
promise of a free re-license to come. Accordingly, the file
LICENSE/GPL was added to this distro, which contains the text of the
GPL version 3.0.
* This release also includes a collection of small documentation
updates and fixes, such as the following: We now use the official
typography for the names 'TTM' and 'D' and such. Added a DOCUMENTATION
READING ORDER section to the README file.
2007-06-20 Darren Duncan <darren@DarrenDuncan.net>
* Muldis::DB version 0.0.0 for Perl 5 is released on CPAN as
Muldis-DB-0.0.0.tar.gz. The rest of this Changes entry refers only to
the portions of it that became part of the Language-MuldisD
distribution following release 0.2.0.
* Initial file versions (not marked though) are: Language.pod 0.0.0.
* As of this release, the Muldis D specification is officially in
pre-alpha development status. A lot of documentation is present, but a
lot isn't. What is mostly done is the higher level documentation.
What is mostly undone is documentation of the API details. What is
already present should be sufficient to begin study of Muldis D such
that it can actually be put to use within the next few weeks or months
as Muldis D is fleshed out. Also, it should be possible now to start
writing code that implements it or uses said.
2006-09-15 thru 2007-06-02
* Started rewriting Rosetta again, but with a name change, since
"Rosetta" was no longer appropriate for various reasons. This rewrite
took the intentionally bad and temporary name QDRDBMS, to be renamed
again (to Muldis DB) later on. With the name change allowed for the
previous version numbering of Rosetta to be dropped, and this rewrite
would eventually be first released as version zero.
* QDRDBMS was started in the wake of having had a lot more experience
in reading up on the truly relational model of data, and was now
designed fundamentally to be the design and implementation of a new
turing complete programming language for working with relational
databases, now called "QDRDBMS D".
* Made an experimental CPAN release of QDRDBMS version 0.0.0 on
2007-05-31, which specifically was a quick branch that stripped out all
the code and just contained the documentation. This was the only CPAN
release of the (partial) project under the QDRDBMS name.
* Shortly after this, QDRDBMS was renamed to its presumably final name
of "Muldis DB", and its command language to "Muldis D". But while
"Muldis D" stuck, "Muldis DB" was fated for a further rename later.
2006-04-14 thru 2006-11-22
* Started a complementary Perl 6 project named "Relation" which was
intended to provide native tuple and relation data types for ordinary
use in Perl 6 programs like other built-in collection types. It is
now stagnant; it will likely get un-stuck after Muldis Rosetta sets an
example for it.
2006-02-01 thru 2006-04-13
* The first simultaneous releases of the Perl 5 and 6 versions of
Rosetta's rewrite occurred on 2006-02-01; they were also the first CPAN
releases of either version. The Perl 6 one was Pugs release 6.2.11
(SVN rev 8934).
* On 2006-02-23 was the first (Perl 5) CPAN release of Rosetta where
the project was then officially an implementation of "The Third
Manifesto", the central work of Darwen and Date's DBMS proposal;
moreover, Rosetta's command language was named "Rosetta D", to be a "D"
language by the terms of said proposal.
* On 2006-03-20 was the (Perl 5) release that declared Rosetta was to
be fundamentally a self-contained relational DBMS (and the core
distribution would bundle such an implementation of its API) rather
than "just" a DBMS wrapper; though extensions could still chose to
operate as wrappers over other DBMSs.
* On 2006-04-13 was the last CPAN release of the Perl 5 Rosetta, and
Pugs 6.2.12 (SVN rev 10930), on 2006-06-26, had the corresponding Perl
6 version; Pugs 6.2.13 (SVN rev 11402), on 2006-10-27, had the last
CPAN release of Perl 6 Rosetta, with trivial Perl 6 only updates.
After this, Pugs would have a Muldis Rosetta instead.
2005-12-06 thru 2006-01-31
* Rosetta started to evolve so that its API and design was based on
relational algebra, which is a lot of smaller generic constructs that
can easily be arranged into queries; this is in contrast to the
previous design based around monolithic and unwieldy SQL "select"
queries. Generally speaking, there was increasing influence on the
design by Hugh Darwen's and Chris Date's proposals on how a truly
relational DBMS should work. This time period also saw very little
code, and almost entirely documentation updates.
2005-12-05
* Darren Duncan is introduced by David Wheeler to the truly relational
model of data, in a posting on the Bricolage development list in the
"Re: [6977] New branch for maintenance of Bricolage 1.10.x." thread.
* David said that Darren's expressed thought, that compound data types
in table fields was a violation of first normal form, was in fact a
misconception about the relational model. David then referenced a
recent interview with C. J. Date.
* This set off a chain of events which was the largest paradigm shift
to ever affect the Rosetta project. While the continuing goal of
Rosetta remained largely the same, the way this was to be accomplished
would become quite different, and the project would gain a new goal, to
help improve the design of relational DBMSs themselves.
2005-09-30 thru 2005-12-04
* Started a full rewrite of Rosetta, with the intent of avoiding being
over-engineered, and cutting corners in the short term so to get
something useable at all sooner. The idea was to focus on vertical
development first, so that at least a subset of features work earlier,
taking the development strategy of Perl6-Pugs itself as an example;
this is in contrast to the more horizontal development strategy of the
first Rosetta implementation.
* Moreover, this rewrite was being done simultaneously in both Perl 5
and Perl 6; each language had its own independent but synchronized
version, with the Perl 6 one intended to be the main future one that
guided design decisions, and the Perl 5 one intended to be the one
production-ready first, to be used until Perl 6 itself was production
ready. That co-development was maintained afterwards, and happens with
the Muldis Rosetta core.
2002-11-12 thru 2005-09-28, plus 2006-01-13
* Developed and released on CPAN the Rosetta DBMS framework, whose
intended purpose was to provide rigorous portability of database
schemas and database-using applications between different SQL DBMS
products. A lot of design documentation was produced, as well as some
code and tests, but while a significant amount of executing code was
produced, no solution emerged that was actually useable for real work;
what did get produced was also unnecessarily complicated.
* The very first CPAN release of anything related to Rosetta was on
2003-01-05, in the form of DBIx::Portable version 0.01, as
DBIx-Portable-0.01.tar.gz.
* A Lightning Talk was also given introducing Rosetta at OSCON 2005;
but it is Muldis Rosetta instead that will fulfill the promises made in
it.
2002-06-07
* Started writing self-contained code components that were explicitly
designed to enable external code that used them to work seamlessly on
multiple database products. Some of this work was reused later in the
Rosetta DBMS framework et al, and hence 2002 is the start of the
declared copyright date range for Muldis D language specification.