NAME

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

VERSION

This document is Muldis::D::Core::Routines version 0.53.0.

PREFACE

This document is part of the Muldis D language specification, whose root document is Muldis::D; you should read that root document before you read this one, which provides subservient details. Moreover, you should read the Muldis::D::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 Muldis::D::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.std.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 2 parameters are mutually commutative. This function will warn if, in regards to the declared types of its arguments, none the following are 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-Array) type, and it is a supertype of the other.

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

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

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

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.std.Core.Universal.treated result Universal params { topic(Universal), as(TypeRef) }

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 sys.std.Integer.difference, which it otherwise wouldn't.

function sys.std.Core.Universal.default result Universal params { of(TypeRef) }

This function is the externalization of a not-Empty data type's type_default function. 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.

function sys.std.Core.Universal.assertion result Universal params { is_true(Bool), result(Universal) }

This function results in the value of its result argument, when its is_true argument is Bool:true. This function will fail if its is_true argument is Bool:false. The purpose of assertion is to perform condition assertions in a pure functional context that may be better done without the overhead of creating a new constrained data type, especially when the assertion is on some fact that is only known after performing calculations from multiple function arguments; this can potentially be done at compile time as per type constraints.

SYSTEM-DEFINED GENERIC SCALAR-CONCERNING FUNCTIONS

These functions are applicable to mainly scalar types, but are generic in that they typically work with any scalar types. Now some of these functions (those with a parameter named possrep) work only with scalar values that have possreps, and not with values of the 2 system-defined scalar types lacking any possreps: Int, String; other functions are not limited in that way, but may be limited in other ways. Note that the terminology used to describe these functions is taking advantage of the fact that a scalar possrep looks just like a tuple. Each possrep parameter is optional and defaults to the empty string if no explicit argument is given to it.

function sys.std.Core.Scalar.attr result ScaTupRel params { topic(Scalar), possrep(Name)?, name(Name) }

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

function sys.std.Core.Scalar.update_attr result Scalar params { topic(Scalar), possrep(Name)?, name(Name), value(ScaTupRel) }

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

function sys.std.Core.Scalar.multi_update result Scalar params { topic(Scalar), possrep(Name)?, attrs(Tuple) }

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

function sys.std.Core.Scalar.projection result Tuple params { topic(Scalar), possrep(Name)?, attrs(set_of.Name) }

This function results in the Tuple that is the projection of the possrep (whose name is given in the possrep argument) 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 the entire named possrep of topic if attrs lists all attributes of that possrep; or, it is the nullary tuple if attrs is empty. This function will fail if possrep specifies a possrep name that topic doesn't have or attrs specifies any attribute names that topic doesn't have.

function sys.std.Core.Scalar.cmpl_projection result Tuple params { topic(Scalar), possrep(Name)?, attrs(set_of.Name) }

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

function sys.std.Core.Scalar.Tuple_from_Scalar result Tuple params { topic(Scalar), possrep(Name)? }

This function results in the Tuple that has all the same attributes of the possrep of topic whose name is given in possrep; in other words, the function results in the externalization of one of a scalar value's possreps. This function will fail if possrep specifies a possrep name that topic doesn't have.

function sys.std.Core.Scalar.Scalar_from_Tuple result Scalar params { topic(Tuple), type(TypeRef), possrep(Name)? }

This function results in the Scalar value whose scalar root (|sub)type is named by type, which has a possrep whose name matches possrep, and whose complete set of attributes of that named possrep match the attributes of topic. This function can be used to select any scalar value at all that has a possrep.

function sys.std.Core.Scalar.order result Order params { topic(Scalar), other(Scalar), assuming(QuasiTuple)? }

This function is the externalization of a scalar root type's type-default (total) order_determination function. This function results in Order:same iff its topic and other arguments are exactly the same value, and otherwise it results in Order:increase if the value of the other argument is considered to be an increase (as defined by the type) over the value of the topic argument, and otherwise it results in Order:decrease as the reverse of the last condition would be true. This function will fail if its topic and other arguments are not values of a common scalar root type that declares a type-default order_determination function; this function will otherwise warn if the declared types of those arguments are not both subtypes of such a common scalar root type. Note that order_determination functions are considered the only fundamental order-sensitive operators, and all others are defined over them. This function also has a Tuple-typed third parameter, named assuming, which carries optional customization details for the order-determination algorithm; this permits the function to implement a choice between multiple (typically similar) ordering algorithms rather than just one, which reduces the number of functions needed for supporting that choice; if the algorithm is not customizable, then a tuple argument would be of degree zero. The assuming parameter is optional and defaults to the zero-attribute tuple if no explicit argument is given to it.

SYSTEM-DEFINED BOOLEAN-CONCERNING FUNCTIONS

These functions implement commonly used boolean operations.

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

This function results in the logical not of its argument.

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

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.std.Core.Bool.or result Bool params { topic(set_of.Bool) }

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.std.Core.Bool.xor result Bool params { topic(bag_of.Bool) }

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.std.Core.Tuple.attr result ScaTupRel params { topic(Tuple), name(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.std.Core.Tuple.update_attr result Tuple params { topic(Tuple), name(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; this function will otherwise warn if the declared type of value isn't a subtype of the declared type of the attribute.

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

This function is like sys.std.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.std.Core.Tuple.static_substitution.

function sys.std.Core.Tuple.rename result Tuple params { topic(Tuple), map(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.std.Core.Tuple.projection result Tuple params { topic(Tuple), attrs(set_of.Name) }

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.std.Core.Tuple.cmpl_projection result Tuple params { topic(Tuple), attrs(set_of.Name) }

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.std.Core.Tuple.wrap result Tuple params { topic(Tuple), inner(set_of.Name), outer(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.std.Core.Tuple.cmpl_wrap result Tuple params { topic(Tuple), cmpl_inner(set_of.Name), outer(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.std.Core.Tuple.unwrap result Tuple params { topic(Tuple), outer(Name) }

This function is the inverse of sys.std.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.std.Core.Tuple.product result Tuple params { topic(quasi_set_of.Tuple) }

This function is similar to sys.std.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. Each \w*assuming parameter is optional and defaults to the zero-attribute tuple if no explicit argument is given to it.

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

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

function sys.std.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.std.Core.Relation.is_subset except that the tuple being looked for doesn't have to be wrapped in a relation. This function will fail|warn if its 2 arguments are incompatible as per is_subset.

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

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

function sys.std.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.std.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.std.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.std.Core.Relation.disjoint_insertion result Relation params { r(Relation), t(Tuple) }

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

function sys.std.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.std.Core.Relation.rename result Relation params { topic(Relation), map(AttrRenameMap) }

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

function sys.std.Core.Relation.projection result Relation params { topic(Relation), attrs(set_of.Name) }

This function is the same as sys.std.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.std.Core.Relation.cmpl_projection result Relation params { topic(Relation), attrs(set_of.Name) }

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

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

This function is the same as sys.std.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.std.Core.Tuple.wrap.

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

This function is the same as sys.std.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.std.Core.Tuple.cmpl_wrap.

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

This function is the inverse of sys.std.Core.Relation.wrap as sys.std.Core.Tuple.unwrap is to sys.std.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.std.Core.Relation.group result Relation params { topic(Relation), inner(set_of.Name), outer(Name) }

This function is similar to sys.std.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.std.Core.Relation.cmpl_group result Relation params { topic(Relation), group_per(set_of.Name), outer(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.std.Core.Relation.ungroup result Relation params { topic(Relation), outer(Name), inner(set_of.Name) }

This function is the inverse of sys.std.Core.Relation.group as sys.std.Core.Relation.unwrap is to sys.std.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.std.Core.Relation.restriction result Relation params { topic(Relation), func(FuncRef), assuming(QuasiTuple)? }

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.std.Core.Relation.semijoin function, which is a simpler-syntax alternative for sys.std.Core.Relation.restriction in its typical usage where restrictions are composed simply of anded or ored tests for attribute value equality.

function sys.std.Core.Relation.cmpl_restriction result Relation params { topic(Relation), func(FuncRef), assuming(QuasiTuple)? }

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.std.Core.Relation.semidifference function.

function sys.std.Core.Relation.extension result Relation params { topic(Relation), func(FuncRef), assuming(QuasiTuple)? }

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.std.Core.Relation.static_extension result Relation params { topic(Relation), attrs(Tuple) }

This function is a simpler-syntax alternative to both sys.std.Core.Relation.extension and sys.std.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.std.Core.Relation.summary result Relation params { topic(Relation), group_per(set_of.Name), summ_func(FuncRef), summ_assuming(QuasiTuple)? }

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.std.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 have attributes with common names but their most specific types would be fatally incompatible in a common relation value; this function will otherwise warn with common-named attributes where their declared types are incompatible as per is_identical.

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

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

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

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 this function will fail. Note that, conceptually union does have an identity value which could be this function's result when topic has zero values, which is the empty relation with the same heading, which is the per-distinct-heading identity value for relational union; however, since a topic with zero values wouldn't know the heading / attribute names for the result relation in question, it seems the best alternative is to require invoking code to work around the limitation somehow, which might mean it will supply the identity value explicitly as an extra topic element.

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

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

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

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 this function will fail. Note that, conceptually intersection does have an identity value which could be this function's result when topic has zero values, which is 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; however, since a topic with zero values wouldn't know the heading / attribute names for the result relation in question (and even if they were, more information on attribute types would be needed to produce said universal relation, and even then it might be infinite or impossibly large), it seems the best alternative is to require invoking code to work around the limitation somehow, which might mean it will supply the identity value explicitly as an extra topic element. 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.

function sys.std.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|warn if its 2 arguments are incompatible as per is_subset. Note that this difference operator is conceptually a special case of semidifference, applicable when the headings of the inputs are the same.

function sys.std.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.std.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|warn any time that join would fail|warn on the same 2 input relations.

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

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 their most specific types would be fatally incompatible in a common relation value; this function will otherwise warn with common-named attributes where their declared types are incompatible as per is_identical. Note that this operation is also legitimately known as natural inner join.

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

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.std.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 GENERIC CONTROL FLOW FUNCTIONS

function sys.std.Core.Control.func_invo result Universal params { function(FuncRef), args(QuasiTuple)? }

This function results in the result of invoking the other function named in its function argument when the latter function is curried by its args argument; each attribute name of args is mapped to a parameter name of the invoked function, and the corresponding attribute value is the corresponding argument for the function invocation. This function will fail if the invoked function has any non-optional parameters such that there aren't any corresponding attributes in args, or if there are any attributes in args that don't have corresponding parameters, or if any attribute values aren't of the declared types of the corresponding parameters. The purpose of func_invo is to support invocation of any function whose name or parameters potentially aren't known until runtime; it forms the foundation of all other system-defined functions that want to invoke a function whose name they take as an argument. The args parameter is optional and defaults to the zero-attribute quasi-tuple if no explicit argument is given to it.

SYSTEM-DEFINED GENERIC UNIVERSAL UPDATERS

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

updater sys.std.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 updater will fail if v isn't of the declared type of the variable behind target; this function will otherwise warn if the declared type of v isn't a subtype of the declared type of the variable behind target.

SYSTEM-DEFINED GENERIC TUPLE VARIABLE UPDATERS

Updaters That Rename Attributes

updater sys.std.Core.Tuple.assign_rename update { topic(Tuple) } read { map(AttrRenameMap) }

This update operator is a short-hand for first invoking the sys.std.Core.Tuple.rename function with the same arguments, and then assigning the result of that function to topic. This procedure is analagous to the data-manipulation phase of a SQL RENAME TABLE|VIEW or ALTER TABLE|VIEW RENAME TO statement iff topic is Database-typed; each tuple of map corresponds to a renamed SQL table.

Updaters That Add Attributes

updater sys.std.Core.Tuple.assign_product update { topic(Tuple) } read { other(Tuple) }

This update operator is a short-hand for first invoking the sys.std.Core.Tuple.product function such that it has 2 input tuples from assign_product's 2 arguments, and then assigning the result of that function to topic. This procedure is analagous to the data-manipulation phase of a SQL CREATE TABLE|VIEW statement iff both arguments are Database-typed; each relation-typed attribute of other corresponds to a created SQL table.

Updaters That Remove Attributes

updater sys.std.Core.Tuple.assign_projection update { topic(Tuple) } read { attrs(set_of.Name) }

This update operator is a short-hand for first invoking the sys.std.Core.Tuple.projection function with the same arguments, and then assigning the result of that function to topic.

updater sys.std.Core.Tuple.assign_cmpl_projection update { topic(Tuple) } read { attrs(set_of.Name) }

This update operator is a short-hand for first invoking the sys.std.Core.Tuple.cmpl_projection function with the same arguments, and then assigning the result of that function to topic. This procedure is analagous to the data-manipulation phase of a SQL DROP TABLE|VIEW statement iff topic is Database-typed; each relation-typed attribute named by attrs corresponds to a dropped SQL table.

SYSTEM-DEFINED GENERIC RELATION VARIABLE UPDATERS

Updaters That Add Tuples

updater sys.std.Core.Relation.assign_insertion update { r(Relation) } read { t(Tuple) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.insertion function with the same arguments, and then assigning the result of that function to r. This updater is analagous to the general case of the single-row SQL "INSERT" statement.

updater sys.std.Core.Relation.assign_disjoint_insertion update { r(Relation) } read { t(Tuple) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.disjoint_insertion function with the same arguments, and then assigning the result of that function to r.

updater sys.std.Core.Relation.assign_union update { topic(Relation) } read { other(Relation) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.union function such that it has 2 input relations from assign_union's 2 arguments, and then assigning the result of that function to topic. This updater is analagous to the general case of the multiple-row SQL "INSERT" statement.

updater sys.std.Core.Relation.assign_disjoint_union update { topic(Relation) } read { other(Relation) }

This update operator is to sys.std.Core.Relation.disjoint_union what the function sys.std.Core.Relation.assign_union is to sys.std.Core.Relation.union.

Updaters That Remove Tuples

updater sys.std.Core.Relation.assign_deletion update { r(Relation) } read { t(Tuple) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.deletion function with the same arguments, and then assigning the result of that function to r.

updater sys.std.Core.Relation.assign_restriction update { topic(Relation) } read { func(FuncRef), assuming(QuasiTuple)? }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.restriction function with the same arguments, and then assigning the result of that function to topic.

updater sys.std.Core.Relation.assign_cmpl_restriction update { topic(Relation) } read { func(FuncRef), assuming(QuasiTuple)? }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.cmpl_restriction function with the same arguments, and then assigning the result of that function to topic. This updater is analagous to the general case of the SQL "DELETE" statement.

updater sys.std.Core.Relation.assign_intersection update { topic(Relation) } read { other(Relation) }

This update operator is to sys.std.Core.Relation.intersection what the function sys.std.Core.Relation.assign_union is to sys.std.Core.Relation.union.

updater sys.std.Core.Relation.assign_difference update { source(Relation) } read { filter(Relation) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.difference function with the same arguments, and then assigning the result of that function to source.

updater sys.std.Core.Relation.assign_semidifference update { source(Relation) } read { filter(Relation) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.semidifference function with the same arguments, and then assigning the result of that function to source. This updater is analagous to the common case of the SQL "DELETE" statement where the criteria is simply a set of and-ed and or-ed value equality tests.

updater sys.std.Core.Relation.assign_semijoin update { source(Relation) } read { filter(Relation) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.semijoin function with the same arguments, and then assigning the result of that function to source.

Updaters That Rename Attributes

updater sys.std.Core.Relation.assign_rename update { topic(Relation) } read { map(AttrRenameMap) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.rename function with the same arguments, and then assigning the result of that function to topic. This procedure is analagous to the data-manipulation phase of a SQL ALTER TABLE|VIEW RENAME COLUMN statement; each tuple of map corresponds to a renamed SQL table column.

Updaters That Add Attributes

updater sys.std.Core.Relation.assign_extension update { topic(Relation) } read { func(FuncRef), assuming(QuasiTuple)? }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.extension function with the same arguments, and then assigning the result of that function to topic.

updater sys.std.Core.Relation.assign_static_extension update { topic(Relation) } read { attrs(Tuple) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.static_extension function with the same arguments, and then assigning the result of that function to topic. This procedure is analagous to the data-manipulation phase of a SQL ALTER TABLE|VIEW ADD COLUMN statement; each attribute of attrs corresponds to an added SQL table column.

Updaters That Remove Attributes

updater sys.std.Core.Relation.assign_projection update { topic(Relation) } read { attrs(set_of.Name) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.projection function with the same arguments, and then assigning the result of that function to topic.

updater sys.std.Core.Relation.assign_cmpl_projection update { topic(Relation) } read { attrs(set_of.Name) }

This update operator is a short-hand for first invoking the sys.std.Core.Relation.cmpl_projection function with the same arguments, and then assigning the result of that function to topic. This procedure is analagous to the data-manipulation phase of a SQL ALTER TABLE|VIEW DROP COLUMN statement; each attribute named by attrs corresponds to an dropped SQL table column.

SYSTEM-DEFINED GENERIC CONTROL FLOW UPDATERS

updater sys.std.Core.Control.upd_invo update { upd_args(QuasiTuple) } read { updater(ProcRef), ro_args(QuasiTuple)? }

This update operator has the same purpose and features as sys.std.Core.Control.func_invo but that it invokes an updater rather than a function; there is no result to deal with, and there are both subject-to-update parameters and read-only parameters of the invoked updater to bind to; they are bound with the attributes of this updater's upd_args and ro_args arguments, respectively. The ro_args parameter is optional and defaults as per the args parameter of func_invo; the upd_args parameter is non-optional because an updater must always be invoked with at least one subject-to-update argument.

SYSTEM-DEFINED GENERIC SYSTEM SERVICES FOR STANDARD I/O

These system services are provided so Muldis D can do basic user input/output by itself, using standard input and standard output, like any general purpose programming language, and help satisfy its need to be computationally complete. For now they just work with plain (Unicode) text data, so one can implement a basic command-line program interface, or do basic invoker-setup file piping, as well as display diagnostics to standard error. These routines are not exhaustive, and their details are subject to future revision.

system_service sys.std.Core.STDIO.read_Text update { target(Text) } read { length_in_graphemes(NNInt) }

This system service routine will attempt to read length_in_graphemes characters from standard input as a single Text value, blocking the current in-DBMS process until it finishes, and then update the variable supplied as its target argument so that it holds the read value. The routine will only fetch fewer than the requested number of characters if the input stream is closed first. This routine will throw an exception if any system errors occur.

system_service sys.std.Core.STDIO.read_Text_line update { target(Text) } read { ignore_empty_lines(Bool)? }

This system service routine is the same as sys.std.Core.STDIO.read_Text except that it will read from standard input until an implementation-defined end-of-line character is read, rather than reading a fixed number of characters; this end-of-line character will not be included in the read Text value. If the ignore_empty_lines argument is Bool:true, then this routine will keep reading lines from standard input until it reads a non-empty line, and then target is only updated to hold that last non-empty line; otherwise, this routine will end as soon as one line is read, even if it is empty.

system_service sys.std.Core.STDIO.write_Text update {} read { v(Text) }

This system service routine will attempt to write the characters of its v argument to standard output, blocking the current in-DBMS process until it finishes. This routine will throw an exception if any system errors occur.

system_service sys.std.Core.STDIO.write_Text_line update {} read { v(Text) }

This system service routine is the same as sys.std.Core.STDIO.write_Text except that it will additionally write an implementation-defined end-of-line character after writing v.

system_service sys.std.Core.STDIO.prompt_Text_line update { target(Text) } read { prompt(Text), ignore_empty_lines(Bool)? }

This system service routine is a wrapper over first invoking sys.std.Core.STDIO.write_Text with its prompt argument and then invoking sys.std.Core.STDIO.read_Text_line with its target argument. A true ignore_empty_lines argument will result in both of the wrapped routines being invoked repeatedly, not just read_text_line.

system_service sys.std.Core.STDIO.error_Text update {} read { v(Text) }

This system service routine is the same as sys.std.Core.STDIO.write_Text except that it will write to standard error rather than standard output.

system_service sys.std.Core.STDIO.error_Text_line update {} read { v(Text) }

This system service routine is the same as sys.std.Core.STDIO.write_Text_line except that it will write to standard error rather than standard output.

SYSTEM-DEFINED GENERIC CONTROL FLOW PROCEDURES

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

procedure sys.std.Core.Control.proc_invo update { upd_args(QuasiTuple)? } read { procedure(ProcRef), ro_args(QuasiTuple)? }

This procedure is the same as sys.std.Core.Control.upd_invo but that it invokes a procedure rather than an updater, and that upd_args is optional.

procedure sys.std.Core.Control.fail update {} read { topic(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.std.Core.Control.try_catch update { try_updating(QuasiTuple)?, catch_updating(QuasiTuple)? } read { try(ProcRef), catch(ProcRef), try_assuming(QuasiTuple)?, catch_assuming(QuasiTuple)? }

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 an 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. Each of the (try|catch)_(updating|assuming) parameters is optional and defaults to the zero-attribute tuple if no explicit argument is given to it.

SYSTEM-DEFINED GENERIC BOOTLOADER EXCLUSIVES

These system services may only be invoked directly by a bootloader routine.

bootloader_exclusive sys.std.Core.Control.start_trans read {}

This system service starts a new child-most transaction.

bootloader_exclusive sys.std.Core.Control.commit_trans read {}

This system service commits the child-most transaction; it will fail if there isn't one.

bootloader_exclusive sys.std.Core.Control.rollback_trans read {}

This system service rolls back the child-most transaction; it will fail if there isn't one.

SEE ALSO

Go to Muldis::D for the majority of distribution-internal references, and Muldis::D::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 Muldis::D for details.

TRADEMARK POLICY

The TRADEMARK POLICY in Muldis::D applies to this file too.

ACKNOWLEDGEMENTS

The ACKNOWLEDGEMENTS in Muldis::D apply to this file too.

cpanm Muldis::D

perl -MCPAN -e shell
install Muldis::D