/ 
Language-MuldisD-0.23.0
/ Language::MuldisD::Core::Routines

NAME

Language::MuldisD::Core::Routines - Muldis D general purpose routines

VERSION

This document is Language::MuldisD::Core::Routines version 0.20.0.

PREFACE

This document is part of the Muldis D language specification, whose root document is Language::MuldisD; you should read that root document before you read this one, which provides subservient details. Moreover, you should read the Language::MuldisD::Core document before this current document, as that forms its own tree beneath a root document branch.

DESCRIPTION

This document contains one or more sections that were moved here from Language::MuldisD::Core so that that other document would not be too large.

SYSTEM-DEFINED GENERIC UNIVERSAL FUNCTIONS

These functions are applicable to values of any data type at all.

function sys.Core.Universal.is_identical result Bool params { topic(Universal), other(Universal) }

This function results in Bool:true iff its 2 arguments are exactly the same value, and Bool:false otherwise. This function's arguments must be of compatible declared types; in this case, 2 declared types are compatible iff at least one of the following is true: 1. they are both subtypes of a common scalar root type; 2. they are both subtypes of a common non-incomplete tuple or relation type, that is they essentially have the same headings; 3. at least one type is a generic (eg-Universal) or incomplete (eg-Seq) type, and it is a supertype of the other. This function's 2 parameters are mutually commutative.

function sys.Core.Universal.is_not_identical result Bool params { topic(Universal), other(Universal) }

This function is exactly the same as sys.Core.Universal.is_identical except that it results in the opposite boolean value when given the same arguments.

function sys.Core.Universal.is_value_of_type result Bool params { topic(Universal), type(Cat.NameChain) }

This function results in Bool:true iff the value of its topic argument is a member of the data type whose name is given in the type argument, and Bool:false otherwise. As trivial cases, this function always results in Bool:true if the named type is Universal, and Bool:false if it is Empty. This function will fail if the named type doesn't exist in the virtual machine.

function sys.Core.Universal.treated result Universal params { topic(Universal), as(Cat.NameChain) }

This function results in the value of its topic argument, but that the declared type of the result is the not-Empty data type whose name is given in the as argument. This function will fail if the named type doesn't exist in the virtual machine, or if topic isn't a member of the named type. The purpose of treated is to permit taking values from a context having a more generic declared type, and using them in a context having a more specific declared type; such an action would otherwise be blocked at compile time due to a type-mismatch error; treated causes the type-mismatch validation, and possible failure, to happen at runtime instead, on the actual value rather than declared value. For example, if you are storing an Int value in a Scalar-typed variable, using treated will cause the compiler to let you use that variable as an argument to Int.sum, which it otherwise wouldn't.

function sys.Core.Universal.default result Universal params { of(Cat.NameChain) }

This function results in the default value of the not-Empty data type whose name is given in the of argument, and the declared type of the result is that same type. This function will fail if the named type doesn't exist in the virtual machine, either at compile or runtime depending whether the type is in the system or user namespace. This function is conceptually implicitly used to provide default values for variables, so they always hold valid values of their declared type.

SYSTEM-DEFINED BOOLEAN-CONCERNING FUNCTIONS

These functions select values of the Bool enumeration.

function sys.Core.Bool.(false|true) result Bool params {}

This selector function results in the Bool:(false|true) value.

These functions implement commonly used boolean operations.

function sys.Core.Bool.not result Bool params { topic(Bool) }

This function results in the logical not of its argument.

function sys.Core.Bool.and result Bool params { topic(SetOfBool) }

This function is a reduction operator that recursively takes each pair of its N input element values and does a logical and (which is both commutative and associative) on them until just one is left, which is the function's result. If topic has zero values, then and results in Bool:true, which is the identity value for logical and.

function sys.Core.Bool.or result Bool params { topic(SetOfBool) }

This function is a reduction operator that recursively takes each pair of its N input element values and does a logical inclusive-or (which is both commutative and associative) on them until just one is left, which is the function's result. If topic has zero values, then or results in Bool:false, which is the identity value for logical inclusive-or.

function sys.Core.Bool.xor result Bool params { topic(BagOfBool) }

This function is a reduction operator that recursively takes each pair of its N input element values and does a logical exclusive-or (which is both commutative and associative) on them until just one is left, which is the function's result. If topic has zero values, then xor results in Bool:false, which is the identity value for logical exclusive-or.

SYSTEM-DEFINED GENERIC TUPLE-CONCERNING FUNCTIONS

These functions are applicable to mainly tuple types, but are generic in that they typically work with any tuple types.

function sys.Core.Tuple.attr result ScaTupRel params { topic(Tuple), name(Cat.Name) }

This function results in the scalar or nonscalar value of the attribute of topic whose name is given by name. This function will fail if name specifies an attribute name that topic doesn't have.

function sys.Core.Tuple.update_attr result Tuple params { topic(Tuple), name(Cat.Name), value(ScaTupRel) }

This function results in its topic argument but that its attribute whose name is name has been updated with a new scalar or nonscalar value given by value. This function will fail if name specifies an attribute name that topic doesn't have, or if the declared type of value isn't a subtype of the declared type of the attribute.

function sys.Core.Tuple.multi_update result Tuple params { topic(Tuple), attrs(Tuple) }

This function is like sys.Core.Tuple.update_attr except that it handles N tuple attributes at once rather than just 1. The heading of the attrs argument must be a subset of the heading of the topic argument; this function's result is topic with all the attribute values of attrs substituted into it. This function could alternately be named sys.Core.Tuple.static_substitution.

function sys.Core.Tuple.rename result Tuple params { topic(Tuple), map(Cat.AttrRenameMap) }

This function results in a Tuple value that is the same as its topic argument but that some of its attributes have different names. Each tuple of the argument map specifies how to rename one topic attribute, with the before and after attributes of a map tuple representing the old and new names of a topic attribute, respectively. As a trivial case, this function's result is topic if map has no tuples. This function supports renaming attributes to each others' names. This function will fail if map specifies any old names that topic doesn't have, or any new names that are the same as topic attributes that aren't being renamed.

function sys.Core.Tuple.projection result Tuple params { topic(Tuple), attrs(Cat.SetOfName) }

This function results in the projection of its topic argument that has just the subset of attributes of topic which are named in its attrs argument. As a trivial case, this function's result is topic if attrs lists all attributes of topic; or, it is the nullary tuple if attrs is empty. This function will fail if attrs specifies any attribute names that topic doesn't have.

function sys.Core.Tuple.cmpl_projection result Tuple params { topic(Tuple), attrs(Cat.SetOfName) }

This function is the same as projection but that it results in the complementary subset of attributes of topic when given the same arguments.

function sys.Core.Tuple.wrap result Tuple params { topic(Tuple), inner(Cat.SetOfName), outer(Cat.Name) }

This function results in a Tuple value that is the same as its topic argument but that some of its attributes have been wrapped up into a new Tuple-typed attribute, which exists in place of the original attributes. The inner argument specifies which topic attributes are to be removed and wrapped up, and the outer argument specifies the name of their replacement attribute. As a trivial case, if inner is empty, then the result has all the same attributes as before plus a new tuple-typed attribute of degree zero; or, if inner lists all attributes of topic, then the result has a single attribute whose value is the same as topic. This function supports the new attribute having the same name as an old one being wrapped into it. This function will fail if inner specifies any attribute names that topic doesn't have, or if outer is the same as topic attributes that aren't being wrapped.

function sys.Core.Tuple.cmpl_wrap result Tuple params { topic(Tuple), cmpl_inner(Cat.SetOfName), outer(Cat.Name) }

This function is the same as wrap but that it wraps the complementary subset of attributes of topic to those specified by cmpl_inner.

function sys.Core.Tuple.unwrap result Tuple params { topic(Tuple), outer(Cat.Name) }

This function is the inverse of sys.Core.Tuple.wrap, such that it will unwrap a Tuple-type attribute into its member attributes. This function will fail if outer specifies any attribute name that topic doesn't have, or if an attribute of topic{outer} is the same as another topic attribute.

function sys.Core.Tuple.product result Tuple params { topic(QuasiSetOfTuple) }

This function is similar to sys.Core.Relation.product but that it works with tuples rather than relations. This function is mainly intended for use in connecting tuples that have all disjoint headings, such as for extending one tuple with additional attributes.

SYSTEM-DEFINED GENERIC SINGLE INPUT RELATION FUNCTIONS

These functions are applicable to mainly relation types, but are generic in that they typically work with any relation types.

function sys.Core.Relation.cardinality result UInt params { topic(Relation) }

This function results in the cardinality of its argument (that is, the count of tuples its body has).

function sys.Core.Relation.is_member result Bool params { r(Relation), t(Tuple) }

This function results in Bool:true iff its t argument matches a tuple of its r argument (that is, iff conceptually t is a member of r), and Bool:false otherwise. This function is like sys.Core.Relation.is_subset except that the tuple being looked for doesn't have to be wrapped in a relation. This function will fail if the 2 arguments don't have the same heading.

function sys.Core.Relation.is_not_member result Bool params { r(Relation), t(Tuple) }

This function is exactly the same as sys.Core.Relation.is_member except that it results in the opposite boolean value when given the same arguments.

function sys.Core.Relation.Tuple_from_Relation result Tuple params { topic(Relation) }

This function results in the Tuple that is the sole member tuple of its argument. This function will fail if its argument does not have exactly one tuple.

function sys.Core.Relation.Relation_from_Tuple result Relation params { topic(Tuple) }

This function results in the Relation value those body has just the one Tuple that is its argument.

function sys.Core.Relation.insertion result Relation params { r(Relation), t(Tuple) }

This function results in a Relation that is the relational union of r and a relation whose sole tuple is t; that is, conceptually the result is t inserted into r. As a trivial case, if t already exists in r, then the result is just r.

function sys.Core.Relation.disjoint_insertion result Relation params { r(Relation), t(Tuple) }

This function is exactly the same as sys.Core.Relation.insertion except that it will fail if t already exists in r.

function sys.Core.Relation.deletion result Relation params { r(Relation), t(Tuple) }

This function results in a Relation that is the relational difference from r of a relation whose sole tuple is t; that is, conceptually the result is t deleted from r. As a trivial case, if t already doesn't exist in r, then the result is just r.

function sys.Core.Relation.rename result Relation params { topic(Relation), map(Cat.AttrRenameMap) }

This function is the same as sys.Core.Tuple.rename but that it operates on and results in a Relation rather than a Tuple.

function sys.Core.Relation.projection result Relation params { topic(Relation), attrs(Cat.SetOfName) }

This function is the same as sys.Core.Tuple.projection but that it operates on and results in a Relation rather than a Tuple. But note that the result relation will have fewer tuples than topic if any topic tuples were non-distinct for just the projected attributes.

function sys.Core.Relation.cmpl_projection result Relation params { topic(Relation), attrs(Cat.SetOfName) }

This function is the same as sys.Core.Tuple.cmpl_projection but that it operates on and results in a Relation rather than a Tuple.

function sys.Core.Relation.wrap result Relation params { topic(Relation), inner(Cat.SetOfName), outer(Cat.Name) }

This function is the same as sys.Core.Tuple.wrap but that it operates on and results in a Relation rather than a Tuple, where each of its member tuples was transformed as per sys.Core.Tuple.wrap.

function sys.Core.Relation.cmpl_wrap result Relation params { topic(Relation), cmpl_inner(Cat.SetOfName), outer(Cat.Name) }

This function is the same as sys.Core.Tuple.cmpl_wrap but that it operates on and results in a Relation rather than a Tuple, where each of its member tuples was transformed as per sys.Core.Tuple.cmpl_wrap.

function sys.Core.Relation.unwrap result Relation params { topic(Relation), outer(Cat.Name), inner(Cat.SetOfName) }

This function is the inverse of sys.Core.Relation.wrap as sys.Core.Tuple.unwrap is to sys.Core.Tuple.wrap. But unlike the Tuple variant of unwrap, this current function requires the extra inner argument to prevent ambiguity in the general case where topic might have zero tuples, because in that situation the most-specific-type of topic{outer} would be Empty, and the names of the attributes to add to topic in place of topic{outer} are not known. This function will fail if topic has at least 1 tuple and inner does not match the names of the attributes of topic{outer}.

function sys.Core.Relation.group result Relation params { topic(Relation), inner(Cat.SetOfName), outer(Cat.Name) }

This function is similar to sys.Core.Relation.wrap but that the topic attribute-wrapping transformations result in new Relation-typed attributes rather than new Tuple-typed attributes, and moreover multiple topic tuples may be combined into fewer tuples whose new Relation-typed attributes have multiple tuples. This function takes a relation of N tuples and divides the tuples into M groups where all the tuples in a group have the same values in the attributes which aren't being grouped (and distinct values in the attributes that are being grouped); it then results in a new relation of M tuples where the new relation-valued attribute of the result has the tuples of the M groups. A grouped relation contains all of the information in the original relation, but it has less redundancy due to redundant non-grouped attributes now just being represented in one tuple per the multiple tuples whose grouped attributes had them in common. A relation having relation-valued attributes like this is a common way to group so-called child tuples under their parents. As a trivial case, if inner is empty, then the result has all the same tuples and attributes as before plus a new relation-typed attribute of degree zero whose value per tuple is of cardinality one; or, if inner lists all attributes of topic, then the result has a single tuple of a single attribute whose value is the same as topic. This function supports the new attribute having the same name as an old one being grouped into it. This function will fail if inner specifies any attribute names that topic doesn't have, or if outer is the same as topic attributes that aren't being grouped.

function sys.Core.Relation.cmpl_group result Relation params { topic(Relation), group_per(Cat.SetOfName), outer(Cat.Name) }

This function is the same as group but that it groups the complementary subset of attributes of topic to those specified by group_per.

function sys.Core.Relation.ungroup result Relation params { topic(Relation), outer(Cat.Name), inner(Cat.SetOfName) }

This function is the inverse of sys.Core.Relation.group as sys.Core.Relation.unwrap is to sys.Core.Relation.wrap; it will ungroup a Relation-type attribute into its member attributes and tuples. A relation can be first grouped and then that result ungrouped to produce the original relation, with no data loss. However, the ungroup of a relation on a relation-valued attribute will lose the information in any outer relation tuples whose inner relation value has zero tuples; a group on this result won't bring them back. This function will fail if outer specifies any attribute name that topic doesn't have, or if an attribute of topic{outer} is the same as another topic attribute.

function sys.Core.Relation.restriction result Relation params { topic(Relation), func(Cat.NameChain), assuming(Tuple) }

This function results in the relational restriction of its topic argument as determined by applying the Bool-resulting function named in its func argument when the latter function is curried by its assuming argument. The result relation has the same heading as topic, and its body contains the subset of topic tuples where, for each tuple, the function named by func results in Bool:true when passed the tuple as its topic argument and assuming as its assuming argument. As a trivial case, if func is defined to unconditionally result in Bool:true, then this function results simply in topic; or, for an unconditional Bool:false, this function results in the empty relation with the same heading. Note that this operation is also legitimately known as where. See also the sys.Core.Relation.semijoin function, which is a simpler-syntax alternative for sys.Core.Relation.restriction in its typical usage where restrictions are composed simply of anded or ored tests for attribute value equality.

function sys.Core.Relation.cmpl_restriction result Relation params { topic(Relation), func(Cat.NameChain), assuming(Tuple) }

This function is the same as restriction but that it results in the complementary subset of tuples of topic when given the same arguments. See also the sys.Core.Relation.semidifference function.

function sys.Core.Relation.extension result Relation params { topic(Relation), func(Cat.NameChain), assuming(Tuple) }

This function results in the relational extension of its topic argument as determined by applying the Tuple-resulting function named in its func argument when the latter function is curried by its assuming argument. The result relation has a heading that is a superset of that of topic, and its body contains the same number of tuples, with all attribute values of topic retained, and possibly extra present, determined as follows; for each topic tuple, the function named by func results in a second tuple when passed the first tuple as its topic argument and assuming as its assuming argument; the first and second tuples must have no attribute names in common, and the result tuple is derived by joining (cross-product) the tuples together. As a trivial case, if func is defined to unconditionally result in the degree-zero tuple, then this function results simply in topic.

function sys.Core.Relation.static_extension result Relation params { topic(Relation), attrs(Tuple) }

This function is a simpler-syntax alternative to both sys.Core.Relation.extension and sys.Core.Relation.product in the typical scenario of extending a relation, given in the topic argument, such that every tuple has mutually identical values for each of the new attributes; the new attribute names and common values are given in the attrs argument.

function sys.Core.Relation.summary result Relation params { topic(Relation), group_per(Cat.SetOfName), summ_func(Cat.NameChain), summ_assuming(Tuple) }

This function provides a convenient context for using aggregate functions to derive a per-group summary relation, which is its result, from another relation, which is its topic argument. This function first performs a cmpl_group on topic using group_per to specify which attributes get grouped into a new relation-valued attribute and which don't; those that don't instead get wrapped into a tuple-valued attribute. Then, per tuple in the main relation, this function applies the Tuple-resulting function named in its summ_func argument when the latter function is curried by its summ_assuming argument (passed to it as just assuming); the curried function has, rather than the typical 1 topic varying parameter, 2 varying parameters named summarize and per, which are valued with the relation-valued attribute and tuple-valued attribute, respectively. As per a function that map applies, the function named by summ_func effectively takes a whole post-grouping input tuple and results in a whole tuple; the applied function would directly invoke any N-ary / aggregate operators, and extract their inputs from (or calculate) summarize as it sees fit. Note that summary is not intended to be used to summarize an entire topic relation at once (except by chance of it resolving to 1 group); you should instead invoke your summarize-all func directly, or inline it, rather than by way of summary, especially if you want a single-tuple result on an empty topic (which summary) won't do.

SYSTEM-DEFINED GENERIC MULTIPLE INPUT RELATION FUNCTIONS

These functions are applicable to mainly relation types, but are generic in that they typically work with any relation types.

function sys.Core.Relation.is_subset result Bool params { look_in(Relation), look_for(Relation) }

This function results in Bool:true iff the set of tuples comprising look_for is a subset of the set of tuples comprising look_in, and Bool:false otherwise. This function will fail if the 2 arguments don't have the same heading.

function sys.Core.Relation.is_not_subset result Bool params { look_in(Relation), look_for(Relation) }

This function is exactly the same as sys.Core.Relation.is_subset except that it results in the opposite boolean value when given the same arguments.

function sys.Core.Relation.union result Relation params { topic(SetOfRelation) }

This function results in the relational union/inclusive-or of the N element values of its argument; it is a reduction operator that recursively takes each pair of input values and relationally unions (which is both commutative and associative) them together until just one is left, which is the result. The result relation has the same heading as all of its inputs, and its body contains every tuple that is in any of the input relations. If topic has zero values, then union results in the empty relation with the same heading, which is the per-distinct-heading identity value for relational union.

function sys.Core.Relation.disjoint_union result Relation params { topic(SetOfRelation) }

This function is exactly the same as sys.Core.Relation.union except that it will fail if any 2 input values have a tuple in common.

function sys.Core.Relation.intersection result Relation params { topic(SetOfRelation) }

This function results in the relational intersection/and of the N element values of its argument; it is a reduction operator that recursively takes each pair of input values and relationally intersects (which is both commutative and associative) them together until just one is left, which is the result. The result relation has the same heading as all of its inputs, and its body contains only the tuples that are in every one of the input relations. If topic has zero values, then intersection results in the universal relation with the same heading (that is, the relation having all the tuples that could ever exist in a relation with that heading), which is the per-distinct-heading identity value for relational intersection. Note that this intersection operator is conceptually a special case of join, applicable when the headings of the inputs are the same, and the other will produce the same result as this when given the same inputs, but with the exception that intersection has a different identity value when given zero inputs. This function will fail on a topic of zero values if the result type's universal relation is impossible or impractically large to represent, such as when any attributes are of infinite types.

function sys.Core.Relation.difference result Relation params { source(Relation), filter(Relation) }

This function results in the relational difference when its filter argument is subtracted from its source argument. The result relation has the same heading as both of its arguments, and its body contains only the tuples that are in source and are not in filter. This function will fail if its 2 arguments do not have the same heading. Note that this difference operator is conceptually a special case of semidifference, applicable when the headings of the inputs are the same.

function sys.Core.Relation.semidifference result Relation params { source(Relation), filter(Relation) }

This function is the same as semijoin but that it results in the complementary subset of tuples of source when given the same arguments. Note that this operation is also legitimately known as antijoin or anti-semijoin.

function sys.Core.Relation.semijoin result Relation params { source(Relation), filter(Relation) }

This function results in the relational semijoin of its source and filter arguments. The result relation has the same heading as source, and its body contains the subset of source tuples that match those of filter as per join. Note that relational semijoin is conceptually a short-hand for first doing an ordinary relational join between its 2 arguments, and then performing a relational projection on all of the attributes that just source has. This function will fail any time that join would fail on the same 2 input relations.

function sys.Core.Relation.join result Relation params { topic(QuasiSetOfRelation) }

This function results in the relational join of the N element values of its argument; it is a reduction operator that recursively takes each pair of input values and relationally joins (which is both commutative and associative) them together until just one is left, which is the result. The result relation has a heading that is a union of all of the headings of its inputs, and its body is the result of first pairwise-matching every tuple of each input relation with every tuple of each other input relation, then where each member of a tuple pair has attribute names in common, eliminating pairs where the values of those attributes differ and unioning the remaining said tuple pairs, then eliminating any result tuples that duplicate others. If topic has zero values, then join results in the nullary relation with one tuple, which is the identity value for relational join. As a trivial case, if any input relation has zero tuples, then the function's result will too; or, if any input is the nullary relation with one tuple, that input can be ignored (see identity value); or, if any 2 inputs have no attribute names in common, then the join of just those 2 is a cartesian product; or, if any 2 inputs have all attribute names in common, then the join of just those 2 is an intersection; or, if for 2 inputs, one's set of attribute names is a proper subset of another's, then the join of just those to is a semijoin with the former filtering the latter. This function will fail if any input relations have attributes with common names but different/incompatible declared types. Note that this operation is also legitimately known as natural inner join.

function sys.Core.Relation.product result Relation params { topic(QuasiSetOfRelation) }

This function results in the relational cartesian/cross product of the N element values of its argument; it is conceptually a special case of join where all input relations have mutually distinct attribute names; unlike join, product will fail if any inputs have attribute names in common. Note that this operation is also legitimately known as cartesian/cross join.

function sys.Core.Relation.quotient result Relation params { dividend(Relation), divisor(Relation) }

This function results in the quotient when its dividend argument is divided by its divisor argument using relational division. Speaking informally, say the relations dividend and divisor are called A and B, and their attribute sets are respectively named {X,Y} and {Y}, then the result relation has a heading composed of attributes {X} (so the result and divisor headings are both complementary subsets of the dividend heading); the result has all tuples {X} such that a tuple {X,Y} appears in A for all tuples {Y} appearing in B; that is, A / B is shorthand for A{X} - ((A{X} join B) - A){X}.

SYSTEM-DEFINED CORE GENERIC QUASI- FUNCTIONS

This documentation is pending.

SYSTEM-DEFINED CORE CATALOG FUNCTIONS

This documentation is pending.

SYSTEM-DEFINED CORE UPDATERS

Generic Universal

These update operators are applicable to values of any data type at all.

updater sys.Core.Universal.assign update { target(Universal) } read { v(Universal) }

This update operator will update the variable supplied as its target argument so that it holds the value supplied as its v argument. This update operator's arguments must be of compatible declared types; in this case, v must be a subtype of target.

SYSTEM-DEFINED CORE SYSTEM SERVICES

These system services are applicable to just one or more specific system-defined core scalar data type.

This documentation is pending.

SYSTEM-DEFINED CORE PROCEDURES

Generic Control-Flow Procedures

These procedures are applicable to use in all kinds of procedures.

procedure sys.Core.Control.fail update {} read { topic(Cat.Exception) }

This procedure will throw the exception given as its argument; this results in the call stack unwinding, and transaction rollbacks, until it is caught.

procedure sys.Core.Control.try_catch update { try_updating(Tuple), catch_updating(Tuple) } read { try(Cat.NameChain), catch(Cat.NameChain), try_assuming(Tuple), catch_assuming(Tuple) }

This procedure invokes the procedure named in its try argument, giving it the arguments try_updating and try_assuming as its updating and assuming arguments, respectively. If the try procedure throws an exception, then any state changes it made roll back (but changes made before that don't), and the call stack unwinds to the try_catch itself; then the procedure named by catch is invoked similarly to try was, with corresponding arguments, but with the extra read-only argument topic whose value is a Cat.Exception; if the catch procedure also throws an exception (such as to say its not handling the thrown one), then that one is not caught and the call stack unwinding plus applicable transaction rollback carries on to the caller of the try_catch. If the try procedure succeeds (doesn't throw an exception), then the catch procedure is not called.

SEE ALSO

Go to Language::MuldisD for the majority of distribution-internal references, and Language::MuldisD::SeeAlso for the majority of distribution-external references.

AUTHOR

Darren Duncan (perl@DarrenDuncan.net)

LICENSE AND COPYRIGHT

This file is part of the formal specification of the Muldis D language.

Muldis D is Copyright © 2002-2008, Darren Duncan.

See the LICENSE AND COPYRIGHT of Language::MuldisD for details.

ACKNOWLEDGEMENTS

The ACKNOWLEDGEMENTS in Language::MuldisD apply to this file too.