NAME

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

VERSION

This document is Muldis::D::Core::Routines version 0.71.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 said other document would not be too large.

SYSTEM-DEFINED GENERIC UNIVERSAL FUNCTIONS

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

sys.std.Core.Universal.is_identical

function sys.std.Core.Universal.is_identical (Bool <-- Universal $topic, Universal $other)

This function results in Bool:true iff its (mutually commutative) 2 arguments are exactly the same value, and Bool:false otherwise. This function will warn if, in regards to the declared types of its arguments, none of the following are true: 1. they are both subtypes of a common q/scalar root type; 2. they are both subtypes of a common complete q/tuple or q/relation type, that is they essentially have the same headings; 3. at least one type is a generic (eg-Universal) or incomplete (eg-Relation) type, and it is a supertype of the other.

sys.std.Core.Universal.is_not_identical

function sys.std.Core.Universal.is_not_identical (Bool <-- Universal $topic, Universal $other)

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.

sys.std.Core.Universal.is_value_of_type

function sys.std.Core.Universal.is_value_of_type (Bool <-- Universal $topic, TypeRef $type)

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.

sys.std.Core.Universal.is_not_value_of_type

function sys.std.Core.Universal.is_not_value_of_type (Bool <-- Universal $topic, TypeRef $type)

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

sys.std.Core.Universal.treated

function sys.std.Core.Universal.treated (Universal <-- Universal $topic, TypeRef $as)

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.

sys.std.Core.Universal.default

function sys.std.Core.Universal.default (Universal <-- TypeRef $of)

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.

sys.std.Core.Universal.assertion

function sys.std.Core.Universal.assertion (Universal <-- Bool $is_true, Universal $result)

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 QUASI-/SCALAR-CONCERNING FUNCTIONS

These functions are applicable to mainly q/scalar types, but are generic in that they typically work with any q/scalar types. Note that the terminology used to describe these functions is taking advantage of the fact that a q/scalar possrep looks just like a q/tuple. Each possrep and name parameter is optional and each defaults to the empty string if no explicit argument is given to it.

sys.std.Core.QScalar.attr

function sys.std.Core.QScalar.attr (Universal <-- QScalar $topic, Name $possrep?, Name $name?)

This function results in the q/scalar or q/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.

sys.std.Core.QScalar.update_attr

function sys.std.Core.QScalar.update_attr (QScalar <-- QScalar $topic, Name $possrep?, Name $name?, Universal $value)

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 q/scalar or q/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.

sys.std.Core.QScalar.multi_update

function sys.std.Core.QScalar.multi_update (QScalar <-- QScalar $topic, Name $possrep?, QTuple $attrs)

This function is like sys.std.Core.QScalar.update_attr except that it handles N q/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.QScalar.static_substitution.

sys.std.Core.QScalar.projection

function sys.std.Core.QScalar.projection (QTuple <-- QScalar $topic, Name $possrep?, set_of.Name $attr_names)

This function results in the QTuple 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 attr_names argument. As a trivial case, this function's result is the entire named possrep of topic if attr_names lists all attributes of that possrep; or, it is the nullary tuple if attr_names is empty. This function will fail if possrep specifies a possrep name that topic doesn't have or attr_names specifies any attribute names that topic doesn't have.

sys.std.Core.QScalar.cmpl_projection

function sys.std.Core.QScalar.cmpl_projection (QTuple <-- QScalar $topic, Name $possrep?, set_of.Name $attr_names)

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.

sys.std.Core.QScalar.QTuple_from_QScalar

function sys.std.Core.QScalar.QTuple_from_QScalar (QTuple <-- QScalar $topic, Name $possrep?)

This function results in the QTuple 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 q/scalar value's possreps. This function will fail if possrep specifies a possrep name that topic doesn't have.

sys.std.Core.QScalar.QScalar_from_QTuple

function sys.std.Core.QScalar.QScalar_from_QTuple (QScalar <-- QTuple $topic, TypeRef $type, Name $possrep?)

This function results in the QScalar value whose q/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 q/scalar value at all that has a possrep.

sys.std.Core.QScalar.order

function sys.std.Core.QScalar.order (Order <-- QScalar $topic, QScalar $other, QTuple $assuming?, Bool $is_reverse_order?)

This order_determination function is the externalization of a q/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 q/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 q/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 QTuple-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 q/tuple argument would be of degree zero. This function also has a Bool-typed fourth parameter, named is_reverse_order; a Bool:false argument means the function's algorithm operates as normal when given any particular 3 other arguments (meaning a sorting operation based on it will place elements in ascending order), while a Bool:true argument means the function's algorithm operates in reverse, so the function results in the reverse Order value it would have otherwise when given the same 3 other arguments (meaning a sorting operation based on it will place elements in descending order). The assuming and is_reverse_order parameters are optional and default to the zero-attribute tuple and Bool:false, respectively, if no explicit arguments are given to them.

sys.std.Core.QScalar.has_possrep

function sys.std.Core.QScalar.has_possrep (Bool <-- QScalar $topic, Name $possrep?)

This function results in Bool:true iff its topic argument has a possrep whose name is given by possrep; otherwise it results in Bool:false.

sys.std.Core.QScalar.possrep_names

function sys.std.Core.QScalar.possrep_names (set_of.Name <-- QScalar $topic)

This function results in the set of the names of the possreps of its argument.

sys.std.Core.QScalar.degree

function sys.std.Core.QScalar.degree (NNInt <-- QScalar $topic, Name $possrep?)

This function results in the degree of its topic argument's possrep whose name is given by possrep (that is, the count of attributes the possrep has).

sys.std.Core.QScalar.has_attrs

function sys.std.Core.QScalar.has_attrs (Bool <-- QScalar $topic, Name $possrep?, set_of.Name $attr_names)

This function results in Bool:true iff, for every one of the attribute names specified by its attr_names argument, its topic argument's possrep whose name is given by possrep has an attribute with that name; otherwise it results in Bool:false. As a trivial case, this function's result is Bool:true if attr_names is empty.

sys.std.Core.QScalar.attr_names

function sys.std.Core.QScalar.attr_names (set_of.Name <-- QScalar $topic, Name $possrep?)

This function results in the set of the names of the attributes of its topic argument's possrep whose name is given by possrep.

SYSTEM-DEFINED BOOLEAN-CONCERNING FUNCTIONS

These functions implement commonly used boolean operations.

sys.std.Core.Bool.not

function sys.std.Core.Bool.not (Bool <-- Bool $topic)

This function results in the logical not of its argument.

sys.std.Core.Bool.and

function sys.std.Core.Bool.and (Bool <-- set_of.Bool $topic?)

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.

sys.std.Core.Bool.or

function sys.std.Core.Bool.or (Bool <-- set_of.Bool $topic?)

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.

sys.std.Core.Bool.xor

function sys.std.Core.Bool.xor (Bool <-- bag_of.Bool $topic?)

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 QUASI-/TUPLE-CONCERNING FUNCTIONS

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

sys.std.Core.QTuple.attr

function sys.std.Core.QTuple.attr (Universal <-- QTuple $topic, Name $name)

This function results in the q/scalar or q/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.

sys.std.Core.QTuple.update_attr

function sys.std.Core.QTuple.update_attr (QTuple <-- QTuple $topic, Name $name, Universal $value)

This function results in its topic argument but that its attribute whose name is name has been updated with a new q/scalar or q/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.

sys.std.Core.QTuple.multi_update

function sys.std.Core.QTuple.multi_update (QTuple <-- QTuple $topic, QTuple $attrs)

This function is like sys.std.Core.QTuple.update_attr except that it handles N q/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.QTuple.static_substitution.

sys.std.Core.QTuple.rename

function sys.std.Core.QTuple.rename (QTuple <-- QTuple $topic, AttrRenameMap $map)

This function results in a QTuple 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.

sys.std.Core.QTuple.projection

function sys.std.Core.QTuple.projection (QTuple <-- QTuple $topic, set_of.Name $attr_names)

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

sys.std.Core.QTuple.cmpl_projection

function sys.std.Core.QTuple.cmpl_projection (QTuple <-- QTuple $topic, set_of.Name $attr_names)

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

sys.std.Core.QTuple.static_extension

function sys.std.Core.QTuple.static_extension (QTuple <-- QTuple $topic, QTuple $attrs)

This function results in the extension of its topic argument by joining that with its attrs argument; the attribute names of the 2 arguments must be disjoint. See also sys.std.Core.QTuple.product for an N-adic version of this.

sys.std.Core.QTuple.wrap

function sys.std.Core.QTuple.wrap (QTuple <-- QTuple $topic, set_of.Name $inner, Name $outer)

This function results in a QTuple value that is the same as its topic argument but that some of its attributes have been wrapped up into a new QTuple-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 a topic attribute that isn't being wrapped.

sys.std.Core.QTuple.cmpl_wrap

function sys.std.Core.QTuple.cmpl_wrap (QTuple <-- QTuple $topic, set_of.Name $cmpl_inner, Name $outer)

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

sys.std.Core.QTuple.unwrap

function sys.std.Core.QTuple.unwrap (QTuple <-- QTuple $topic, Name $outer)

This function is the inverse of sys.std.Core.QTuple.wrap, such that it will unwrap a QTuple-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} has the same name as another topic attribute.

sys.std.Core.QTuple.product

function sys.std.Core.QTuple.product (QTuple <-- quasi_set_of.QTuple $topic)

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

SYSTEM-DEFINED GENERIC SINGLE INPUT QUASI-/RELATION FUNCTIONS

These functions are applicable to mainly q/relation types, but are generic in that they typically work with any q/relation types. Each \w*assuming parameter is optional and defaults to the zero-attribute tuple if no explicit argument is given to it.

sys.std.Core.QRelation.cardinality

function sys.std.Core.QRelation.cardinality (NNInt <-- QRelation $topic)

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

sys.std.Core.QRelation.is_member

function sys.std.Core.QRelation.is_member (Bool <-- QRelation $r, QTuple $t)

This function results in Bool:true iff its t argument matches a q/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.QRelation.is_subset except that the q/tuple being looked for doesn't have to be wrapped in a q/relation. This function will warn if its 2 arguments' common-named attributes have declared types that are incompatible as per is_identical.

sys.std.Core.QRelation.is_not_member

function sys.std.Core.QRelation.is_not_member (Bool <-- QRelation $r, QTuple $t)

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

sys.std.Core.QRelation.QTuple_from_QRelation

function sys.std.Core.QRelation.QTuple_from_QRelation (QTuple <-- QRelation $topic)

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

sys.std.Core.QRelation.QRelation_from_QTuple

function sys.std.Core.QRelation.QRelation_from_QTuple (QRelation <-- QTuple $topic)

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

sys.std.Core.QRelation.insertion

function sys.std.Core.QRelation.insertion (QRelation <-- QRelation $r, QTuple $t)

This function results in a QRelation that is the relational union of r and a q/relation whose sole q/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.

sys.std.Core.QRelation.disjoint_insertion

function sys.std.Core.QRelation.disjoint_insertion (QRelation <-- QRelation $r, QTuple $t)

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

sys.std.Core.QRelation.deletion

function sys.std.Core.QRelation.deletion (QRelation <-- QRelation $r, QTuple $t)

This function results in a QRelation that is the relational difference from r of a q/relation whose sole q/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.

sys.std.Core.QRelation.rename

function sys.std.Core.QRelation.rename (QRelation <-- QRelation $topic, AttrRenameMap $map)

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

sys.std.Core.QRelation.projection

function sys.std.Core.QRelation.projection (QRelation <-- QRelation $topic, set_of.Name $attr_names)

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

sys.std.Core.QRelation.cmpl_projection

function sys.std.Core.QRelation.cmpl_projection (QRelation <-- QRelation $topic, set_of.Name $attr_names)

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

sys.std.Core.QRelation.wrap

function sys.std.Core.QRelation.wrap (QRelation <-- QRelation $topic, set_of.Name $inner, Name $outer)

This function is the same as sys.std.Core.QTuple.wrap but that it operates on and results in a QRelation rather than a QTuple, where each of its member q/tuples was transformed as per sys.std.Core.QTuple.wrap. The result relation has the same cardinality as topic.

sys.std.Core.QRelation.cmpl_wrap

function sys.std.Core.QRelation.cmpl_wrap (QRelation <-- QRelation $topic, set_of.Name $cmpl_inner, Name $outer)

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

sys.std.Core.QRelation.unwrap

function sys.std.Core.QRelation.unwrap (QRelation <-- QRelation $topic, Name $outer, set_of.Name $inner)

This function is the inverse of sys.std.Core.QRelation.wrap as sys.std.Core.QTuple.unwrap is to sys.std.Core.QTuple.wrap. But unlike the QTuple variant of unwrap, this current function requires the extra inner argument to prevent ambiguity in the general case where topic might have zero q/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 q/tuple and inner does not match the names of the attributes of topic{outer}. This function will fail with a non-Relation valued topic unless, for every q/tuple of topic, the attribute specified by outer is valued with a q/tuple of the same degree and heading (attribute names); this failure is because there would be no consistent set of attribute names to extend topic with (a problem that would never happen by definition with a non-quasi relation topic).

sys.std.Core.QRelation.group

function sys.std.Core.QRelation.group (QRelation <-- QRelation $topic, set_of.Name $inner, Name $outer)

This function is similar to sys.std.Core.QRelation.wrap but that the topic attribute-wrapping transformations result in new QRelation-typed attributes rather than new QTuple-typed attributes, and moreover multiple topic q/tuples may be combined into fewer q/tuples whose new QRelation-typed attributes have multiple q/tuples. This function takes a q/relation of N q/tuples and divides the q/tuples into M groups where all the q/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 q/relation of M q/tuples where the new q/relation-valued attribute of the result has the q/tuples of the M groups. A grouped q/relation contains all of the information in the original q/relation, but it has less redundancy due to redundant non-grouped attributes now just being represented in one q/tuple per the multiple q/tuples whose grouped attributes had them in common. A q/relation having q/relation-valued attributes like this is a common way to group so-called child q/tuples under their parents. As a trivial case, if inner is empty, then the result has all the same q/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 q/tuple of a single attribute whose value is the same as topic (except that the result has zero tuples when topic does). 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.

sys.std.Core.QRelation.cmpl_group

function sys.std.Core.QRelation.cmpl_group (QRelation <-- QRelation $topic, set_of.Name $group_per, Name $outer)

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

sys.std.Core.QRelation.ungroup

function sys.std.Core.QRelation.ungroup (QRelation <-- QRelation $topic, Name $outer, set_of.Name $inner)

This function is the inverse of sys.std.Core.QRelation.group as sys.std.Core.QRelation.unwrap is to sys.std.Core.QRelation.wrap; it will ungroup a QRelation-type attribute into its member attributes and q/tuples. A q/relation can be first grouped and then that result ungrouped to produce the original q/relation, with no data loss. However, the ungroup of a q/relation on a q/relation-valued attribute will lose the information in any outer q/relation q/tuples whose inner q/relation value has zero q/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} has the same name as another topic attribute. This function will fail with a non-Relation valued topic unless, for every q/tuple of topic, the attribute specified by outer is valued with a q/relation of the same degree and heading (attribute names); this failure is because there would be no consistent set of attribute names to extend topic with (a problem that would never happen by definition with a non-quasi relation topic).

sys.std.Core.QRelation.restriction

function sys.std.Core.QRelation.restriction (QRelation <-- QRelation $topic, FuncRef $func, QTuple $assuming?)

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 q/relation has the same heading as topic, and its body contains the subset of topic q/tuples where, for each q/tuple, the function named by func results in Bool:true when passed the q/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.QRelation.semijoin function, which is a simpler-syntax alternative for sys.std.Core.QRelation.restriction in its typical usage where restrictions are composed simply of anded or ored tests for attribute value equality.

sys.std.Core.QRelation.restriction_and_cmpl

function sys.std.Core.QRelation.restriction_and_cmpl (QTuple <-- QRelation $topic, FuncRef $func, QTuple $assuming?)

This function performs a 2-way partitioning of all the q/tuples of topic and results in a binary q/tuple whose attribute values are each q/relations that have the same heading as topic and complementary subsets of its q/tuples; the 2 result attributes have the names pass and fail, and their values are what sys.std.Core.QRelation.restriction and sys.std.Core.QRelation.cmpl_restriction, respectively, would result in when given the same arguments.

sys.std.Core.QRelation.cmpl_restriction

function sys.std.Core.QRelation.cmpl_restriction (QRelation <-- QRelation $topic, FuncRef $func, QTuple $assuming?)

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

sys.std.Core.QRelation.extension

function sys.std.Core.QRelation.extension (QRelation <-- QRelation $topic, set_of.Name $attr_names, FuncRef $func, QTuple $assuming?)

This function results in the relational extension of its topic argument as determined by applying the QTuple-resulting function named in its func argument when the latter function is curried by its assuming argument. The result q/relation has a heading that is a superset of that of topic, and its body contains the same number of q/tuples, with all attribute values of topic retained, and possibly extra present, determined as follows; for each topic q/tuple, the function named by func results in a second q/tuple when passed the first q/tuple as its topic argument and assuming as its assuming argument; the first and second q/tuples must have no attribute names in common, and the result q/tuple is derived by joining (cross-product) the q/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. Now, extension requires the extra attr_names argument to prevent ambiguity in the general case where topic might have zero q/tuples, because in that situation, func would never be invoked, and the names of the attributes to add to topic are not known (we don't generally assume that extension can reverse-engineer func to see what attributes it would have resulted in). This function will fail if topic has at least 1 q/tuple and the result of func does not have matching attribute names to those named by attr_names.

sys.std.Core.QRelation.static_extension

function sys.std.Core.QRelation.static_extension (QRelation <-- QRelation $topic, QTuple $attrs)

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

sys.std.Core.QRelation.summary

function sys.std.Core.QRelation.summary (QRelation <-- QRelation $topic, set_of.Name $group_per, set_of.Name $summ_attr_names, FuncRef $summ_func, QTuple $summ_assuming?)

This function provides a convenient context for using aggregate functions to derive a per-group summary q/relation, which is its result, from another q/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 q/relation-valued attribute and which don't; those that don't instead get wrapped into a q/tuple-valued attribute. Then, per binary q/tuple in the main q/relation, this function applies the QTuple-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 q/relation-valued attribute and q/tuple-valued attribute, respectively. As per a function that extension applies, the function named by summ_func effectively takes a whole post-grouping input q/tuple and results in a partial q/tuple that would be joined by summary with the per q/tuple to get the result q/tuple; the applied function would directly invoke any N-adic/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 q/relation at once (except by chance of it resolving to 1 group); you should instead invoke your summarize-all summ_func directly, or inline it, rather than by way of summary, especially if you want a single-q/tuple result on an empty topic (which summary) won't do. Now, summary requires the extra summ_attr_names argument to prevent ambiguity in the general case where topic might have zero q/tuples, because in that situation, summ_func would never be invoked, and the names of the attributes to add to per are not known (we don't generally assume that summary can reverse-engineer summ_func to see what attributes it would have resulted in). This function will fail if topic has at least 1 q/tuple and the result of summ_func does not have matching attribute names to those named by summ_attr_names.

sys.std.Core.QRelation.cardinality_per_group

function sys.std.Core.QRelation.cardinality_per_group (QRelation <-- QRelation $topic, set_of.Name $group_per, Name $count_attr_name)

This function is a convenient shorthand for the common use of summary that is just counting the tuples of each group. This function is like cmpl_group but that the single added attribute, rather than an RVA of the grouped topic attributes, has the cardinality that said RVA would have had. The result's heading consists of the attributes named in group_per plus the attribute named in count_attr_name (a PInt).

SYSTEM-DEFINED GENERIC MULTIPLE INPUT QUASI-/RELATION FUNCTIONS

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

sys.std.Core.QRelation.is_subset

function sys.std.Core.QRelation.is_subset (Bool <-- QRelation $look_in, QRelation $look_for)

This function results in Bool:true iff the set of q/tuples comprising look_for is a subset of the set of q/tuples comprising look_in, and Bool:false otherwise. This function will warn if the input q/relations common-named attributes have declared types that are incompatible as per is_identical.

sys.std.Core.QRelation.is_not_subset

function sys.std.Core.QRelation.is_not_subset (Bool <-- QRelation $look_in, QRelation $look_for)

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

sys.std.Core.QRelation.union

function sys.std.Core.QRelation.union (QRelation <-- quasi_set_of.QRelation $topic)

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 q/relation has the same heading as all of its inputs, and its body contains every q/tuple that is in any of the input q/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 q/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.

sys.std.Core.QRelation.disjoint_union

function sys.std.Core.QRelation.disjoint_union (QRelation <-- quasi_set_of.QRelation $topic)

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

sys.std.Core.QRelation.intersection

function sys.std.Core.QRelation.intersection (QRelation <-- quasi_set_of.QRelation $topic)

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 q/relation has the same heading as all of its inputs, and its body contains only the q/tuples that are in every one of the input q/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 q/relation with the same heading (that is, the q/relation having all the q/tuples that could ever exist in a q/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 q/relation in question (and even if they were, more information on attribute types would be needed to produce said universal q/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.

sys.std.Core.QRelation.difference

function sys.std.Core.QRelation.difference (QRelation <-- QRelation $source, QRelation $filter)

This function results in the relational difference when its filter argument is subtracted from its source argument. The result q/relation has the same heading as both of its arguments, and its body contains only the q/tuples that are in source and are not in filter. This function will warn if the input q/relations common-named attributes have declared types that are incompatible as per is_identical. Note that this difference operator is conceptually a special case of semidifference, applicable when the headings of the inputs are the same.

sys.std.Core.QRelation.semidifference

function sys.std.Core.QRelation.semidifference (QRelation <-- QRelation $source, QRelation $filter)

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

sys.std.Core.QRelation.semijoin_and_diff

function sys.std.Core.QRelation.semijoin_and_diff (QTuple <-- QRelation $source, QRelation $filter)

This function performs a 2-way partitioning of all the q/tuples of source and results in a binary q/tuple whose attribute values are each q/relations that have the same heading as source and complementary subsets of its q/tuples; the 2 result attributes have the names pass and fail, and their values are what sys.std.Core.QRelation.semijoin and sys.std.Core.QRelation.semidifference, respectively, would result in when given the same arguments.

sys.std.Core.QRelation.semijoin

function sys.std.Core.QRelation.semijoin (QRelation <-- QRelation $source, QRelation $filter)

This function results in the relational semijoin of its source and filter arguments. The result q/relation has the same heading as source, and its body contains the subset of source q/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 q/relations.

sys.std.Core.QRelation.join

function sys.std.Core.QRelation.join (QRelation <-- quasi_set_of.QRelation $topic?)

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 q/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 q/tuple of each input q/relation with every q/tuple of each other input q/relation, then where each member of a q/tuple pair has attribute names in common, eliminating pairs where the values of those attributes differ and unioning the remaining said q/tuple pairs, then eliminating any result q/tuples that duplicate others. If topic has zero values, then join results in the nullary q/relation with one q/tuple, which is the identity value for relational join. As a trivial case, if any input q/relation has zero q/tuples, then the function's result will too; or, if any input is the nullary q/relation with one q/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 two is a semijoin with the former filtering the latter. This function will warn if any input q/relations have attributes with common names where their declared types are incompatible as per is_identical. Note that this operation is also legitimately known as natural inner join.

sys.std.Core.QRelation.product

function sys.std.Core.QRelation.product (QRelation <-- quasi_set_of.QRelation $topic?)

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 q/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.

sys.std.Core.QRelation.quotient

function sys.std.Core.QRelation.quotient (QRelation <-- QRelation $dividend, QRelation $divisor)

This function results in the quotient when its dividend argument is divided by its divisor argument using relational division. Speaking informally, say the q/relations dividend and divisor are called A and B, and their attribute sets are respectively named {X,Y} and {Y}, then the result q/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 q/tuples {X} such that a q/tuple {X,Y} appears in A for all q/tuples {Y} appearing in B; that is, A / B is shorthand for A{X} - ((A{X} * B) - A){X}.

SYSTEM-DEFINED GENERIC CONTROL FLOW FUNCTIONS

sys.std.Core.Control.func_invo

function sys.std.Core.Control.func_invo (Universal <-- FuncRef $function, QTuple $args?)

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.

sys.std.Core.Universal.assign

updater sys.std.Core.Universal.assign (Universal &$target, Universal $v)

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 QUASI-/TUPLE VARIABLE UPDATERS

Updaters That Rename Attributes

sys.std.Core.QTuple.assign_rename

updater sys.std.Core.QTuple.assign_rename (QTuple &$topic, AttrRenameMap $map)

This update operator is a short-hand for first invoking the sys.std.Core.QTuple.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

sys.std.Core.QTuple.assign_static_extension

updater sys.std.Core.QTuple.assign_static_extension (QTuple &$topic, QTuple $attrs)

This update operator is a short-hand for first invoking the sys.std.Core.QTuple.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 CREATE TABLE|VIEW statement iff both arguments are Database-typed; each q/relation-typed attribute of attrs corresponds to a created SQL table.

Updaters That Remove Attributes

sys.std.Core.QTuple.assign_projection

updater sys.std.Core.QTuple.assign_projection (QTuple &$topic, set_of.Name $attr_names)

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

sys.std.Core.QTuple.assign_cmpl_projection

updater sys.std.Core.QTuple.assign_cmpl_projection (QTuple &$topic, set_of.Name $attr_names)

This update operator is a short-hand for first invoking the sys.std.Core.QTuple.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 q/relation-typed attribute named by attr_names corresponds to a dropped SQL table.

SYSTEM-DEFINED GENERIC QUASI-/RELATION VARIABLE UPDATERS

Updaters That Add Q/Tuples

sys.std.Core.QRelation.assign_insertion

updater sys.std.Core.QRelation.assign_insertion (QRelation &$r, QTuple $t)

This update operator is a short-hand for first invoking the sys.std.Core.QRelation.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.

sys.std.Core.QRelation.assign_disjoint_insertion

updater sys.std.Core.QRelation.assign_disjoint_insertion (QRelation &$r, QTuple $t)

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

sys.std.Core.QRelation.assign_union

updater sys.std.Core.QRelation.assign_union (QRelation &$topic, QRelation $other)

This update operator is a short-hand for first invoking the sys.std.Core.QRelation.union function such that it has 2 input q/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.

sys.std.Core.QRelation.assign_disjoint_union

updater sys.std.Core.QRelation.assign_disjoint_union (QRelation &$topic, QRelation $other)

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

Updaters That Remove Q/Tuples

sys.std.Core.QRelation.assign_deletion

updater sys.std.Core.QRelation.assign_deletion (QRelation &$r, QTuple $t)

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

sys.std.Core.QRelation.assign_restriction

updater sys.std.Core.QRelation.assign_restriction (QRelation &$topic, FuncRef $func, QTuple $assuming?)

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

sys.std.Core.QRelation.assign_cmpl_restriction

updater sys.std.Core.QRelation.assign_cmpl_restriction (QRelation &$topic, FuncRef $func, QTuple $assuming?)

This update operator is a short-hand for first invoking the sys.std.Core.QRelation.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.

sys.std.Core.QRelation.assign_intersection

updater sys.std.Core.QRelation.assign_intersection (QRelation &$topic, QRelation $other)

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

sys.std.Core.QRelation.assign_difference

updater sys.std.Core.QRelation.assign_difference (QRelation &$source, QRelation $filter)

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

sys.std.Core.QRelation.assign_semidifference

updater sys.std.Core.QRelation.assign_semidifference (QRelation &$source, QRelation $filter)

This update operator is a short-hand for first invoking the sys.std.Core.QRelation.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.

sys.std.Core.QRelation.assign_semijoin

updater sys.std.Core.QRelation.assign_semijoin (QRelation &$source, QRelation $filter)

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

Updaters That Rename Attributes

sys.std.Core.QRelation.assign_rename

updater sys.std.Core.QRelation.assign_rename (QRelation &$topic, AttrRenameMap $map)

This update operator is a short-hand for first invoking the sys.std.Core.QRelation.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

sys.std.Core.QRelation.assign_extension

updater sys.std.Core.QRelation.assign_extension (QRelation &$topic, set_of.Name $attr_names, FuncRef $func, QTuple $assuming?)

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

sys.std.Core.QRelation.assign_static_extension

updater sys.std.Core.QRelation.assign_static_extension (QRelation &$topic, QTuple $attrs)

This update operator is a short-hand for first invoking the sys.std.Core.QRelation.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

sys.std.Core.QRelation.assign_projection

updater sys.std.Core.QRelation.assign_projection (QRelation &$topic, set_of.Name $attr_names)

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

sys.std.Core.QRelation.assign_cmpl_projection

updater sys.std.Core.QRelation.assign_cmpl_projection (QRelation &$topic, set_of.Name $attr_names)

This update operator is a short-hand for first invoking the sys.std.Core.QRelation.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 attr_names corresponds to an dropped SQL table column.

SYSTEM-DEFINED GENERIC CONTROL FLOW UPDATERS

sys.std.Core.Control.upd_invo

updater sys.std.Core.Control.upd_invo (ProcRef $updater, QTuple &$upd_args, QTuple $ro_args?)

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.

sys.std.Core.STDIO.read_Text

system_service sys.std.Core.STDIO.read_Text (Text &$target, NNInt $length_in_graphemes)

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.

sys.std.Core.STDIO.read_Text_line

system_service sys.std.Core.STDIO.read_Text_line (Text &$target, Bool $ignore_empty_lines?)

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.

sys.std.Core.STDIO.write_Text

system_service sys.std.Core.STDIO.write_Text (Text $v)

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.

sys.std.Core.STDIO.write_Text_line

system_service sys.std.Core.STDIO.write_Text_line (Text $v)

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.

sys.std.Core.STDIO.prompt_Text_line

system_service sys.std.Core.STDIO.prompt_Text_line (Text &$target, Text $prompt, Bool $ignore_empty_lines? )

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.

sys.std.Core.STDIO.error_Text

system_service sys.std.Core.STDIO.error_Text (Text $v)

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.

sys.std.Core.STDIO.error_Text_line

system_service sys.std.Core.STDIO.error_Text_line (Text $v)

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.

sys.std.Core.Control.proc_invo

procedure sys.std.Core.Control.proc_invo (ProcRef $procedure, QTuple &$upd_args?, QTuple $ro_args?)

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.

sys.std.Core.Control.fail

procedure sys.std.Core.Control.fail (Exception $topic)

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

sys.std.Core.Control.try_catch

procedure sys.std.Core.Control.try_catch (ProcRef $try, QTuple &$try_updating?, QTuple $try_assuming?, ProcRef $catch, QTuple &$catch_updating?, QTuple $catch_assuming?)

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.

sys.std.Core.Control.start_trans

bootloader_exclusive sys.std.Core.Control.start_trans ()

This system service starts a new child-most transaction.

sys.std.Core.Control.commit_trans

bootloader_exclusive sys.std.Core.Control.commit_trans ()

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

sys.std.Core.Control.rollback_trans

bootloader_exclusive sys.std.Core.Control.rollback_trans ()

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-2009, Muldis Data Systems, Inc.

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