Muldis::D --------------------------------------------------------------------------- 2008-07-21 Darren Duncan * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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_date_(utc|local )". 2008-06-04 Darren Duncan * 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 * 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 * 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 * 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 * Muldis::D version 0.29.0 is released on CPAN as Muldis-D-0.29.0.tar.gz. * New file versions are: D.pm 0.29.0 and Types_Catalog.pod 0.25.0 and Types.pod and Routines.pod and Integer.pod and Blob.pod and Text.pod and Set.pod and Sequence.pod and Bag.pod and Rational.pod 0.23.0 and Nonscalar.pod 0.22.0 and Basics.pod and PTMD_Tiny.pod 0.21.0 and HDMD_Perl_Tiny.pod 0.18.0. The other pre-existing versioned files are unchanged. * (Basics.pod) Added new "User Namespace Correspondence" pod section under ENTITY NAMES. It says how the namespaces *.lib and *.data inter-relate, for example when they need to have corresponding sections and when they need to have non-conflicting ones. Also, when a depot has no subdepots or packages, then its "dep.data" is "just a database". * (Basics.pod) Added new "Referencing Data Types" pod section under ENTITY NAMES. It specifies a couple new language features, the first of which lets you directly reference types that were baked into the external interfaces of other entities like variables or routines, as if they were normal explicitly declared types; also you can simply take the corresponding tuple type for a relation type or vice-versa; the second feature is that you can tersely declare simple collection types inline, such as sets or sequences of Foo, saving the language and users from a proliferation of explicitly declared simple (|quasi-)nonscalar types like C or C. * (Types.pod) Removed the 6 explicitly declared tuple type factories "(|Quasi)(Set|Seq|Bag)Elem", which are now superfluous as you should now be able to use the "tuple_from" syntax on the "(|Quasi)(Set|Seq|Bag)" type factories instead, if you need them. * (Types.pod, Types_Catalog.pod, Integer.pod, Blob.pod, Text.pod, Rational.pod) Removed the 38 explicitly declared 'Of' types which are now superfluous: 24 "(Set|Maybe|Seq|Bag)Of(Bool|Int|UInt|Blob|Text|Rat)", 4 "(Set|Bag)Of(Tuple|Relation)", SetOfBag, MaybeOfTuple, SeqOfSeq, 2 "QuasiSetOf(Tuple|Relation)", SeqOfProcStmt, 4 "SetOf(Name|NameExprMap|SetOfName|NameChain)". * (Types_Catalog.pod, Routines.pod, Integer.pod, Blob.pod, Text.pod, Nonscalar.pod, Set.pod, Sequence.pod, Bag.pod, Rational.pod) Updated all references to the aforementioned deleted 'Of' types, in type attributes and routine signatures, to refer to the implicitly generated '_of' versions instead. In Types_Catalog.pod, this also means that the whole SYSTEM-DEFINED CORE QUASI-CATALOG PARAMETERIZED TYPES pod section was eliminated. * (Types.pod) Updated descriptions of the Database and Single types. * (Types_Catalog.pod) Updated the 4 "Cat.(System|Federation|Depot|Package)" types to ensure that they actually are "Database" types and not "just Tuple" types, since each "cat" variable is supposed to be a valid "database". The only change for each of the 4 types was to convert type of its "comment" attribute from "Cat.Comment" (a scalar) to "single_of.Cat.Comment" (a relation); the latter type was also added under the misc collection types section. Also clarified that the "Cat.ExprNodeSet" type qualifies as a db type. * (Types_Catalog.pod) Updated the 4 "Cat.Sys(Nsp|Func|Upd|Proc)Set" types to flesh out the definition of their 'parent' attributes (which had been left 'TODO'), and expanded the description of the "namespaces" attribute of the "Cat.System" type. * (Types_Catalog.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Refactored the catalog types for defining data types. Previously, there was just the single C main type, plus 2 supporting enumerated types, that handled all of special types, root scalar and nonscalar types, domain types and union etc types. Now C 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 * 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 * 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 * 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:{ }" it is "Scalar:::{ }". 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 * 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 ''; 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 * 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 * 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..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 * 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 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 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 * 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 * 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 * 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 * 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 * Language::MuldisD version 0.20.0 is released on CPAN as Language-MuldisD-0.20.0.tar.gz. * New file versions are: MuldisD.pm 0.20.0 and Core.pod 0.17.2 and Basics.pod 0.14.0 and PTMD_Tiny.pod 0.12.0 and HDMD_Perl_Tiny.pod 0.9.0 and SeeAlso.pod 0.3.4. The other pre-existing versioned files are unchanged. * (MuldisD.pm, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Renamed the constant first part of a fully-qualified name format for a Muldis D language variant, from 'MuldisD' to 'Muldis_D'. This is to help not perpetuate the myth that the normal/correct way to spell the language name is with MuldisD (1 word) rather than Muldis D (2 words); I have already seen a number of places using that shortened form, incorrectly. Note that the only reason the package name has them rammed together is because that is normal practice for Perl namespaces, which the spec is written under. * (Basics.pod, Core.pod, PTMD_Tiny.pod, HDMD_Perl_Tiny.pod, SeeAlso.pod) Rewrote the "Representation" POD sub-section of the "MULDIS D" POD main section of Basics.pod, which included renaming the "Concrete" and "Abstract" dialect groupings to "Plain Text" and "Hosted Data". Then renamed any references to said groupings in all 5 files. * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Rewrote most of the DESCRIPTION pod in light of both the "Representation" change and MuldisD.pm's new VERSIONING section, to conform to them and remove redundancies. Also smaller changes for the same reasons in other parts of the 2 Tiny files. In HDMD_Perl_Tiny.pod, split the GENERAL STRUCTURE pod section into itself and LANGUAGE NAME, the latter portion being rewritten. * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Shortened the syntax for a Cat.Name value, which huffmanizes the grammars more and also allows other improvements. The cat_name grammar token no longer specifies a "Cat.Name:" prefix, and the Cat.Name phmd node is now simply a Perl Str rather than being a 2-element Array; any parsing context that is expecting a generic literal grammar token or generic phmd node will interpret a character string without metadata as being a Cat.Name. * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Updated every nonscalar literal grammar token and phmd node to remove its element that specifies a predefined type name which constrains/defines the literal's heading. This meta-data was verbosity that couldn't really be used except within the DBMS, wherein it already existed there in code definitions that is processing the literals. As an exception to this straight-removal, for plain relation literals, a new replacement feature was added for the removed, which specifies the relation's attribute list when the relation has no tuples to provide that information. Given that this attribute list is formatted differently than a tuple list, just one of those things appears in a relation literal, and a parser can easily distinguish between them. * (PTMD_Tiny.pod, HDMD_Perl_Tiny.pod) Fleshed out or fixed the syntaxes for specifying Cat.NameChain literals. * (PTMD_Tiny.pod) Added the syntax to call procedures, thus making a PTMD_Tiny code file actually able to represent a Muldis D 'main' routine, and hence actually represent a program; which is simply a sequence of procedure calls following a language name declaration. The literal-defining syntax which still makes up most of the grammar is now specifically for defining arguments for the procedure calls 2008-02-07 Darren Duncan * 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 * 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 * 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 binary 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 * 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 * 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-ary relational operators; all are in the 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-ary 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 * 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-ary 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 * Language::MuldisD version 0.14.0 is released on CPAN as Language-MuldisD-0.14.0.tar.gz. * This release coincides with the 20th birthday of Perl; Larry Wall released Perl 1 to the public on 1987 December 18th. Moreover, on this 20th birthday is the general/stable release of Perl 5.10, its best yet. * New file versions are: MuldisD.pm 0.14.0 and Core.pod 0.12.0 and Basics.pod 0.10.2 and Grammar.pod 0.7.2 and PerlHosted.pod 0.4.2. The other pre-existing versioned files are unchanged. * (Basics.pod) Small updates to the ROUTINES main section. * (Core.pod, Grammar.pod, PerlHosted.pod) Added 4 new trivial data type definitions 'sys.Core.(|Quasi)(Tuple|Relation).D0', some of which were previously referenced but not defined; also corrected any references that said 'D0C(0|1)' to just say'D0'. * (Core.pod) Added new pseudo-type sys.Core.Some.ScaTupRel, which is essentially a union type over Scalar|Tuple|Relation; it is for tersely refering to the general type of a scalar|tuple|relation attribute. * (Core.pod) Added 3 new Int functions, 'increase' and 'decrease' (meaning '++' and '--'), and 'factorial'. * (Core.pod) Added 2 new Tuple functions 'attr_from_Tuple' and 'Tuple_from_attr', which work with degree-one tuples; they are analagous to the 2 "(T|R) from (R|T)" Relation functions that work with cardinality-one relations. Also added 2 new Tuple functions 'attr' and 'update_attr', which read or write an attribute in an arbitrary tuple. * (Core.pod) Added new Relation function 'power_set', which results in a Set of all subsets of its Relation argument (which could itself be just a Set). (Note: Not sure whether or not this is actually useful.) * (Core.pod) Added descriptions to the Relation functions group|ungroup, updated those of tuple wrap|unwrap. Added 3 new complementary tuple|relation functions cmpl_wrap|cmpl_group. * (Core.pod) Fleshed out the Relation function 'substitution', and added 2 new relational functions, 'substitution_in_(restriction|semijoin)'. While 'substitution' will transform all tuples unconditionally, the 2 new 'in' functions let one keep the substitutions within a subset of the tuples. * (Core.pod) Added new Relation function 'map', which provides a convenient one-place generalization of per-tuple transformations that otherwise might require the chaining of up to a half-dozen other operators like restriction, extension, and rename; like Perl's "map", or SQL's generic select-list. * (Core.pod) Fleshed out the Relation function 'summary', giving it a full parameter list and description. Note that this function is only intended to be used in situations where the corresponding SQL would involve a GROUP BY, and there is to be one result tuple per group, which also means an empty result relation from an empty input relation. Those who want their summary to be one tuple for the entire input, even an empty one, would just invoke the N-ary / 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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|)..* ; nat.(data|type|rtn).* -> (app|glo.).* ; 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 * 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 * 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 * 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 * Language::MuldisD version 0.4.0 is released on CPAN as Language-MuldisD-0.4.0.tar.gz. * Renamed MuldisD.pod to MuldisD.pm, and added an empty dummy package declaration of Language::MuldisD to it, all for the sole purpose of helping the CPAN indexer link to this distribution properly; it doesn't work when the namespace file is plain pod. For similar reasons, the version number of MuldisD.pm will now always be kept in sync with the whole-distribution version number declared in the Makefile.PL. * Also renamed Language.pod to Basics.pod. * New file versions are: MuldisD.pm and Basics.pod and Core.pod and Grammar.pod and Num.pod and Temporal.pod 0.4.0. The other pre-existing versioned files are unchanged. * (Basics.pod) Introduced complete vs parameterized types. * (Basics.pod) Every data type is now named and is referred to by that name, the change being that only scalar types used to have names. This said, the actual identities of types haven't changed, so 2 differently-named declarations of types that aren't scalar and have the same structure will still be considered to be the same actual type; the names for types that aren't scalars are simply aliases for this identity. This change was made to greatly simplify (and reduce errors in) the process of declaring data types, particularly hierarchical types, and declaring nonscalar values. * (Core.pod) Added new operators Universal.(is_value_of_type|treat|default). * (Core.pod) Renamed each of the operators Universal.(equal|not_equal) and Relation.(empty|not_empty) to prepend an "is_". * (Core.pod, Num.pod, Temporal.pod) Updated each of the ordinal data types to specify what their minimum and maximum values are, or whether said are infinities. * (Core.pod) Redefined the Maybe-returning N-ary functions Ordinal.(min|max) with versions that instead try to return that functions' identity value when given zero argument values, and fails/dies in just specific situations where said identity is impossibly or impractically large to handle. Also added 2 new functions Ordinal.maybe_(min|max) that provide the old behaviour. * (Core.pod) Redefined the N-ary functions Blob.(and|or|xor) from resulting in Maybes to resulting in identity values on zero inputs. Also corrected the Relation.intersection function definition such that its identity value is actually the universal relation for its heading, not the empty relation; depending how big that is, the function may now possibly fail on zero input values. Also added new function Relation.not, which results in its argument subtracted from the universal relation for the same heading; this may possibly fail if that is too big a value. * (Temporal.pod) Restricted the Temporal.Duration(|OfDays) types to be specific to data with time zone offsets, and added 2 more types Temporal.Duration(|OfDays)NoTZ to handle the other possibility; the idea is that the former should be considered more accurate than the latter, as per DateTime vs DateTimeNoTZ. Also updated all 4 to permit negative durations in addition to positive ones. Also rearranged the types to group all the with-timezone and no-timezone together. * (Grammar.pod) Rewrote the representative Concrete Muldis D grammar so that it is formatted as an actual compiling (though otherwise untested) Perl 6 grammar, rather than the pseudo-LALR grammar. Also, the rewritten grammar is actually complete, unlike the many "todo" gaps in the old. Not that it won't stand to be further improved later. * (Grammar.pod) Added new EXAMPLES documentation section which shows actual Concrete Muldis D code fragments. * Added new file lib/Language/MuldisD/PerlHosted.pod, which starts at version 0.0.0. This file parallels Grammar.pod, but instead shows what arrangement of core Perl data structures make up Perl hosted Abstract Muldis D, which is the recommended interchange format between Muldis D implementations and Perl applications. With code examples! This file also stands as a recommendation for a general AST for use by database related modules, such as ORMs, to specify database queries with. 2007-07-24 Darren Duncan * 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 * 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 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 * 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 * Muldis::DB version 0.1.0 for Perl 5 is released on CPAN as Muldis-DB-0.1.0.tar.gz. The rest of this Changes entry refers only to the portions of it that became part of the Language-MuldisD distribution following release 0.2.0. * This is a major release that focuses on overhauling or defining part of the Muldis D meta-model / system catalog, which is essential for supporting any user-defined DBMS entities, that is, for doing anything remotely useful. Said overhaul is expected to be staged over 3-4 consecutive releases, of which the current one is essentially just updating documentation; not much code was changed by this release. * As of this release, all pod-only files now also have version numbers, shown in the VERSION docs by NAME, like code-containing modules do; the initial version numbers are all 0.1.0. * Muldis D now has 2 representation formats (Concrete Muldis D, Abstract Muldis D) rather than 3 (relations, ASTs, strings). * Rearranged any relevant docs so that the most important core scalar types are now in the order [Bool, Int, Blob, Text] and the relation type factory Maybe now appears after Set. * Muldis D now has a new scalar data type, "Order", which is an enumeration (like "Bool" is) of 3 values: [Increase, Same, Decrease]; it is the result type of any binary comparison operator that underlies the likes of less|greater-than or min|max or sorting operations. * Muldis D now has the new scalar types "Cat.ShortName" and "Cat.LongName", which replace the also removed "Cat.EntityName" and its (as yet unused) system-defined subtypes. * Split up Language.pod 6 ways, into itself and Language/(Core|Catalog).pod and Language/Ext/(Num|Temporal|Spatial).pod. For the most part, the only initial content of the 5 new files are corresponding portions of what used to be the SYSTEM-DEFINED DATA TYPES and (actually empty) SYSTEM-DEFINED ROUTINES main documentation sections of Language.pod, but that the CATALOGS main section was also moved to Catalog.pod; Language.pod retained all the other documentation sections that it previously had. (Language.pod retained about 75% of its previous content; about 25% was moved out.) * Further updated the 5 language files with type definitions, to update some definitions, and also to add a small TYPE SUMMARY main doc section to each file. * Updated Core.pod to add several main doc sections that have an initial complement of system-defined routines. In particular, the equal|not_equal|assign routines that all types have are now defined, and all the common boolean and integer operators were added, and some converter routines such as int-from-text et al, were all added. Many other operator definitions are pending, especially the relational ones. * Added new file lib/Muldis/DB/Language/Grammar.pod, which describes Concrete Muldis D details that aren't applicable to Abstract Muldis D. 2007-06-29 Darren Duncan * 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 * 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.