NAME
Muldis::D::Core::Types - Muldis D general purpose data types
VERSION
This document is Muldis::D::Core::Types version 0.95.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.
TYPE SUMMARY
Following are all the data types and data type factories described in this document, arranged in a type graph according to their proper sub|supertype relationships:
sys.std.Core.Type.Universal
sys.std.Core.Type.Empty
sys.std.Core.Type.Scalar
sys.std.Core.Type.DHScalar
# The following are all regular ordered scalar types.
sys.std.Core.Type.Bool
sys.std.Core.Type.Int
sys.std.Core.Type.NNInt
sys.std.Core.Type.PInt
sys.std.Core.Type.PInt2_N
sys.std.Core.Type.Blob
sys.std.Core.Type.OctetBlob
sys.std.Core.Type.Text
sys.std.Core.Type.Rat
sys.std.Core.Type.NNRat
sys.std.Core.Type.PRat
sys.std.Core.Type.Instant
sys.std.Core.Type.Duration
# The following are mostly nonscalar type factories.
sys.std.Core.Type.Tuple
sys.std.Core.Type.DHTuple
sys.std.Core.Type.Database
sys.std.Core.Type.Interval
sys.std.Core.Type.DHInterval
sys.std.Core.Type.Relation
sys.std.Core.Type.DHRelation
sys.std.Core.Type.Set
sys.std.Core.Type.DHSet
sys.std.Core.Type.Maybe
sys.std.Core.Type.DHMaybe
sys.std.Core.Type.Single
sys.std.Core.Type.DHSingle
sys.std.Core.Type.Array
sys.std.Core.Type.DHArray
sys.std.Core.Type.Bag
sys.std.Core.Type.DHBag
# The following are all reference types.
sys.std.Core.Type.Reference
sys.std.Core.Type.ExternalNote that sys.std.Core.Type.Empty is a proper subtype of all of the other types in this graph, but every other type has only one immediate supertype shown, and hence the graph of them is a simple hierarchy.
Similarly, most sys.std.Core.Type.Relation subtypes have at least 2 parent types; the above graph shows one view of their relationships, and here is another view of those:
sys.std.Core.Type.Universal
sys.std.Core.Type.Empty
# The following are mostly nonscalar type factories.
sys.std.Core.Type.Relation
sys.std.Core.Type.DHRelation
sys.std.Core.Type.DHSet
sys.std.Core.Type.DHMaybe
sys.std.Core.Type.DHSingle
sys.std.Core.Type.DHArray
sys.std.Core.Type.DHBag
sys.std.Core.Type.Set
sys.std.Core.Type.Maybe
sys.std.Core.Type.Single
sys.std.Core.Type.Array
sys.std.Core.Type.BagSYSTEM-DEFINED CORE MAXIMAL AND MINIMAL DATA TYPES
These core data types are special and are the only Muldis D types that are neither scalar nor nonscalar nor reference types. They are all system-defined and it is impossible for users to define more types of this nature.
sys.std.Core.Type.Universal
This is an enumeration data type. The Universal type is the maximal type of the entire Muldis D type system, and contains every value that can possibly exist. Every other (non-aliased) type is implicitly a proper subtype of Universal, and Universal is implicitly a union type over all other types. Its default value is Bool:false. The cardinality of this type is infinity.
sys.std.Core.Type.Empty
This is an enumeration data type. The Empty type is the minimal type of the entire Muldis D type system, and is the only type that contains exactly zero values. Every other (non-aliased) type is implicitly a proper supertype of Empty and Empty is implicitly an intersection type over all other types. It has no default value. The cardinality of this type is zero.
SYSTEM-DEFINED CORE SCALAR DATA TYPES
These core scalar data types are the most fundamental Muldis D types. Plain Text Muldis D provides a specific syntax per type to select a value of every one of these types (or of their super/subtypes), which does not look like a routine invocation, but rather like a scalar literal in a typical programming language; details of that syntax are not given here, but in Muldis::D::Dialect::PTMD_STD. Hosted Data Muldis D as hosted in another language will essentially use literals of corresponding host language types, whatever they use for eg booleans and integers and character strings, but tagged with extra meta-data if the host language is more weakly typed or lacks one-to-one type correspondence; see Muldis::D::Dialect::HDMD_Perl6_STD or Muldis::D::Dialect::HDMD_Perl5_STD for a Perl 6|5-based example. These types, except for Scalar and DHScalar, are all ordered.
sys.std.Core.Type.Scalar
This is an enumeration data type. The Scalar type is the maximal type of all Muldis D scalar types, and contains every scalar value that can possibly exist. Every other (non-aliased) scalar type is implicitly a proper subtype of Scalar, and Scalar is implicitly a union type over all other scalar types. Its default value is Bool:false. The cardinality of this type is infinity.
sys.std.Core.Type.DHScalar
This is an enumeration data type. DHScalar is a proper subtype of Scalar where every one of its possreps' attributes is restricted to be of just certain categories of data types, rather than allowing any data types at all; related to this restriction, any dh-scalar value is allowed to be stored in a global/persisting relational database but any other scalar value may only be used for transient data. The DHScalar type is the maximal type of all Muldis D dh-scalar types, and contains every dh-scalar value that can possibly exist. Every other (non-aliased) dh-scalar type is implicitly a proper subtype of DHScalar, and DHScalar is implicitly a union type over all other dh-scalar types. Its default value is Bool:false. The cardinality of this type is infinity.
sys.std.Core.Type.Bool
This is a structure data type. Bool consists of just the 2 values false and true. A Bool represents a truth value, and is the result type of any is_identical or is_not_identical routine; it is the only essential general-purpose scalar data type of a generic D language, although not the only essential one in Muldis D. A Bool has 2 system-defined possreps, named name and int. The name possrep directly matches the conception of the type as consisting of 2 character string values; it consists of 1 Name-typed attribute whose name is the empty string. The int possrep consists of 1 Int-typed attribute whose name is the empty string and whose value must be one of [0, 1]; the 2 values of each possrep correspond in the same order as they are documented here. The default and minimum value of Bool is false; its maximum value is true. The cardinality of this type is 2. The Bool type has a default ordering algorithm that corresponds directly to that of its int possrep attribute; false is ordered before true. The Bool type has an implementation hint for less intelligent Muldis D implementations, that suggests using the int possrep as the basis for the physical representation.
The value Bool:false is also known as false and contradiction and ⊥. The value Bool:true is also known as true and tautology and ⊤.
sys.std.Core.Type.Int
This is a structure data type. An Int is a single exact integral number of any magnitude. An Int has 1 system-defined possrep whose name is the empty string, which has of 1 SEString-typed attribute whose name is the empty string. Its default value is zero; its minimum and maximum values are conceptually infinities and practically impossible. The cardinality of this type is infinity; to define a most-generalized finite Int subtype, you must specify the 2 integer end-points of the inclusive range that all its values are in. The Int type has a default ordering algorithm; for 2 distinct Int values, the value closer to negative infinity is ordered before the value closer to positive infinity.
sys.std.Core.Type.NNInt
This is an enumeration data type. NNInt (non-negative integer) is a proper subtype of Int where all member values are greater than or equal to zero. Its minimum value is zero.
sys.std.Core.Type.PInt
This is an enumeration data type. PInt (positive integer) is a proper subtype of NNInt where all member values are greater than zero. Its default and minimum value is 1.
sys.std.Core.Type.PInt2_N
This is an enumeration data type. PInt2_N is a proper subtype of PInt where all member values are greater than 1. Its default and minimum value is 2.
sys.std.Core.Type.Blob
This is a structure data type. A Blob is an undifferentiated string of bits. A Blob has 1 system-defined possrep named bits which consists of 1 BString-typed attribute whose name is the empty string; each element of bits is either 0 to represent a low bit or 1 to represent a high bit. A Blob is a simple wrapper for a BString and all of its other details such as default and minimum and maximum values and cardinality and default ordering algorithm all correspond directly. But Blob is explicitly disjoint from BString due to having a different intended interpretation.
sys.std.Core.Type.OctetBlob
This is an enumeration data type. OctetBlob is a proper subtype of Blob where all member values have a length in bits that is an even multiple of 8 (or is zero). An OctetBlob adds 1 system-defined possrep named octets which consists of 1 OString-typed attribute whose name is the empty string. The octets and bits possreps correspond as you might expect, such that each element of the sole attribute of octets maps to 8 consecutive elements of the sole attribute of bits; with each 8 bits corresponding to an octet, the lowest-element-indexed bit corresponds to the highest bit of the octet when the latter is encoded as a standard two's complement binary unsigned integer, and the highest-element-indeed bit corresponds to the lowest bit of the octet. The reason the OctetBlob type is system-defined as distinct from Blob is for convenience of users since it is likely the vast majority of Blob values consist of whole octets and users would want to work with them in those terms.
sys.std.Core.Type.Text
This is a structure data type. A Text is a string of Unicode abstract characters which is formatted as a sequence of Unicode abstract codepoints in canonical decomposed normal form (NFD). Two Text will generally match at the grapheme abstraction level. Of course, a Muldis D implementation doesn't actually have to store character data in NFD; but default matching semantics need to be as if it did. A Text has 1 system-defined possrep named nfd_codes which consists of 1 UCPString-typed attribute whose name is the empty string; each element of nfd_codes represents a Unicode standard version 5.1.0 character abstract codepoint number. A Text is a simple wrapper for a UCPString and all of its other details such as default and minimum and maximum values and cardinality and default ordering algorithm (sorting is numeric by abstract codepoint number) all correspond directly. But Text is explicitly disjoint from UCPString due to having a different intended interpretation. In regards to ordering, possibly the standard Unicode Collation Algorithm (UCA) also works this way, assuming it is totally ordered, but that's unsure. TODO: Support customization parameters for default text sorting.
sys.std.Core.Type.Rat
This is a structure data type. A Rat (scalar) is a single exact rational number of any magnitude and precision. It is conceptually a composite type with 2 main system-defined possreps, called ratio and float, both of which are defined over several Int.
The ratio possrep consists of 2 attributes: numerator (an Int), denominator (a PInt); the conceptual value of a Rat is the result of rational-dividing its numerator by its denominator. Because in the general case there are an infinite set of [numerator,denominator] integer pairs that denote the same rational value, the ratio possrep carries the normalization constraint that numerator and denominator must be coprime, that is, they have no common integer factors other than 1.
The float possrep consists of 3 attributes: mantissa (an Int), radix (a PInt2_N), exponent (an Int); the conceptual value of a Rat is the result of multiplying its mantissa by the result of taking its radix to the power of its exponent. The float possrep carries the normalization constraint that among all the [mantissa,radix,exponent] triples which would denote the same rational value, the only allowed triple is the one having both the radix with the lowest value (that is closest to or equal to 2) and the exponent with the highest value (that is closest to positive infinity). Note: this constraint could stand to be rephrased for simplification or correction, eg if somehow the sets of candidate triples sharing the lowest radix and sharing the highest exponent have an empty intersection.
The default value of Rat is zero; its minimum and maximum values are conceptually infinities and practically impossible. The cardinality of this type is infinity; to define a most-generalized finite Rat subtype, you must specify the greatest magnitude value denominator, plus the 2 integer end-points of the inclusive range of the value numerator; or alternately you must specify the greatest magnitude value mantissa (the maximum precision of the number), and specify the greatest magnitude value radix, plus the 2 integer end-points of the inclusive range of the value exponent (the maximum scale of the number). Common subtypes specify that the normalized radixes of all their values are either 2 or 10; types such as these will easily map exactly to common human or physical numeric representations, so they tend to perform better.
The Rat type has a default ordering algorithm which is conceptually the same as for Int; for 2 distinct Rat values, the value closer to negative infinity is ordered before the value closer to positive infinity.
The Rat type has an implementation hint for less intelligent Muldis D implementations, that suggests using the float possrep as the basis for the physical representation.
sys.std.Core.Type.NNRat
This is an enumeration data type. NNRat (non-negative rational) is a proper subtype of Rat where all member values are greater than or equal to zero (that is, the numerator|mantissa is greater than or equal to zero). Its minimum value is zero.
sys.std.Core.Type.PRat
This is an enumeration data type. PRat (positive rational) is a proper subtype of NNRat where all member values are greater than zero (that is, the numerator|mantissa is greater than zero). Its default and minimum value is 1.
sys.std.Core.Type.Instant
This is a structure data type. An Instant is a single point in time which is specified with arbitrary precision in terms of atomic seconds with fractions. That is, an Instant is defined as a point on the canonical continuous timeline of International Atomic Time (TAI; this is a perfectly linear scale with no discontinuities), specified by a scalar number of TAI seconds since the TAI epoch, which is exactly midnight at the start of January 1st of the year 1958 CE. Put another way, the Instant type is intended to have exactly the same meaning as the same-named type of Perl 6 (see http://perlcabal.org/syn/S02.html for details).
An Instant has 1 system-defined possrep named tai_instant which consists of 1 Rat-typed attribute named seconds. An Instant is a simple wrapper for a Rat and all of its other details such as default and minimum and maximum values and cardinality and default ordering algorithm all correspond directly. But Instant is explicitly disjoint from Rat due to having a different intended interpretation.
The Instant type is intended more for use with system event time-stamps or sensitive scientific applications and is not necessarily the best choice for common human-specified temporal artifacts according to various calendars, since there is no fixed conversion rate between them in the general case that includes future dates, and also calendar-based artifacts may be very non-specific; see also the Muldis D Temporal Extension for a selection of other temporal data types defined in terms of calendars.
sys.std.Core.Type.Duration
This is a structure data type. A Duration is a single amount of time, which is specified with arbitrary precision in terms of the same units as an Instant is structured with. A Duration is not fixed to any point in time. A Duration is the result type of taking the difference between two Instant values, but it is not defined in terms of said two values. The Duration type is intended to have exactly the same meaning as the same-named type of Perl 6, as per Instant. A Duration has 1 system-defined possrep named tai_duration which consists of 1 Rat-typed attribute named seconds. A Duration is a simple wrapper for a Rat in all ways as per Instant. But Duration is explicitly disjoint from Instant due to having a different intended interpretation. The Duration type is intended more for benchmarking or scientific applications and is not intended for human-specified calendar based artifacts; again see the Muldis D Temporal Extension for alternatives.
SYSTEM-DEFINED CORE NONSCALAR DATA TYPES
These core nonscalar data types permit transparent/user-visible compositions of multiple values into other conceptual values. For all nonscalar types, their cardinality is mainly or wholly dependent on the data types they are composed of.
sys.std.Core.Type.Tuple
This is a primitive data type. The Tuple type is the maximal type of all Muldis D tuple (nonscalar) types, and contains every tuple value that could possibly exist. A Tuple is an unordered heterogeneous collection of 0..N named attributes (the count of attributes being its degree), where all attribute names are mutually distinct, and each attribute may be of distinct types; the mapping of a tuple's attribute names and their declared data types is called the tuple's heading. Its default value is the sole tuple value that has zero attributes. The cardinality of a complete Tuple type (if it has no type constraints other than those of its constituent attribute types) is equal to the product of the N-adic multiplication where there is an input to that multiplication for each attribute of the tuple and the value of the input is the cardinality of the declared type of the attribute; for a Tuple subtype to be finite, all of its attribute types must be.
sys.std.Core.Type.DHTuple
This is an enumeration data type. DHTuple is a proper subtype of Tuple where every one of its attributes is restricted to be of just certain categories of data types, rather than allowing any data types at all; related to this restriction, any dh-tuple value is allowed to be stored in a global/persisting relational database but any other tuple value may only be used for transient data. The DHTuple type is the maximal type of all Muldis D dh-tuple (dh-nonscalar) types, and contains every dh-tuple value that could possibly exist. Its default value is the same as that of Tuple and matters of its cardinality are determined likewise.
The only member value of DHTuple that has exactly zero attributes is also known by the special name Tuple:d0 aka d0, which serves as the default value of the 3 types [|DH]Tuple and Database.
sys.std.Core.Type.Database
This is an enumeration data type. Database is a proper subtype of DHTuple where all of its attributes are each of dh-relation types or of database types (the leaves of this recursion are all dh-relation types); it is otherwise the same. The 3 system-defined user-data variables named [fed|dep|sdp].data are all of "just" the Database type, or are of its proper subtypes.
sys.std.Core.Type.Interval
This is an enumeration data type. An Interval is a Tuple. It defines a single bounded interval or finite interval in terms of 2 endpoint values plus an indicator of whether either, both, or none of the endpoint values are included in the interval.
An Interval has these 4 attributes:
min|max-Universal-
These are the interval endpoint values;
mindefines the left|start|from endpoint andmaxdefines the right|end|to endpoint. The endpoint values conceptually must be of the same, totally-ordered type (typically one ofInt,Rat,Text,Instant, etc), although strictly speaking they may be of any types at all; in the latter case, to actually make practical use of such intervals, anorder-determinationfunction must explicitly be employed. excludes_[min|max]-Bool-
If
excludes_minorexcludes_maxareBool:true, thenminormaxis not considered to be included within the interval, respectively; otherwise, it is considered to be included within the interval. If both endpoints are within the interval (the use case which Muldis D optimizes its syntax for), the interval is closed; otherwise if both endpoints are not in the interval, the interval is open.
The Interval type supports empty intervals (which include no values at all) at least as a matter of simplicity in that it doesn't place any restrictions on the combination of attribute values an Interval value may have, such as that max can't be before min. This liberal design is also necessary to support the general case where the relative order of the min and max values is situation-dependent on what order-determination function is used with the interval; that function also determines what type's concept of order is being applied, and so it also determines whether or not a given interval is considered empty or not. With respect to each compatible order-determination function, an Interval is considered empty iff at least one of the following is true: 1. Its min is greater than its max. 2. Its min is equal to its max and at least one of excludes_min or excludes_max is true. 3. Both excludes_min and excludes_max are true and min and max are consecutive values. And so, there are many distinct Interval values that are conceptually empty intervals, and the is_identical function should not be used to test an Interval for being empty or not.
The default value of Interval represents an empty interval where its min attribute is Bool:true and its other 3 attributes are Bool:false.
The Interval type has no support for unbounded/infinite or half-bounded intervals that is orthogonal to data type. However, if there are any types with their own special values to represent infinities, then those special values can be uded for endpoints of intervals over those types. As of this writing, no system-defined types have values for infinities, so only user-defined types would leverage this.
The Interval type only represents a continuous interval, but a discontinuous interval may be effectively represented by a set of Interval values, either a relation_from.Interval or a set_of.Interval. See also the Muldis::D::Ext::Interval extension.
sys.std.Core.Type.DHInterval
This is an enumeration data type. DHInterval is a proper subtype of Interval where every one of its values is also a DHTuple. In general practice, all Interval values are DHInterval values, because their endpoints would all be DHScalar values. The default value of DHInterval is the same as that of Interval.
sys.std.Core.Type.Relation
This is a primitive data type. The Relation type is the maximal type of all Muldis D relation (nonscalar) types, and contains every relation value that could possibly exist. A Relation is analogous to a set of 0..N tuples where all tuples have the same heading (the degrees match and all attribute names, and typically corresponding declared data types, match), but that a Relation data type still has its own corresponding heading (attribute names and declared data types) even when it consists of zero tuples. Its default value is the sole relation value that has zero tuples and zero attributes. The cardinality of a complete Relation type (if it has no type constraints other than those of its constituent attribute types) is equal to 2 raised to the power of the cardinality of the complete Tuple type with the same heading. A relation data type can also have (unique) keys each defined over a subset of its attributes, which constrain its set of values relative to there being no explicit keys, but having the keys won't turn an infinite relation type into a finite one.
sys.std.Core.Type.DHRelation
This is an enumeration data type. DHRelation is a proper subtype of Relation where every one of its attributes is restricted to be of just certain categories of data types, rather than allowing any data types at all; related to this restriction, any dh-relation value is allowed to be stored in a global/persisting relational database but any other relation value may only be used for transient data. The main difference from its supertype is that a dh-relation's dh-tuples' headings all have matching declared data types for corresponding attributes, while with relations they don't have to. The DHRelation type is the maximal type of all Muldis D dh-relation (dh-nonscalar) types, and contains every dh-relation value that could possibly exist. Its default value is the same as that of Relation and matters of its cardinality are determined likewise.
The only member value of DHRelation that has exactly zero attributes and exactly zero tuples is also known by the special name Relation:d0c0 aka d0c0, which serves as the default value of the 2 types [|DH]Relation. The only member value of DHRelation that has exactly zero attributes and exactly one tuple is also known by the special name Relation:d0c1 aka d0c1. Note that The Third Manifesto also refers to these 2 values by the special shorthand names TABLE_DUM and TABLE_DEE, respectively.
sys.std.Core.Type.Set
This is an enumeration data type. Set is a proper subtype of Relation that has 1 attribute, and its name is value; it can be of any declared type. A Set subtype is normally used by any system-defined N-adic operators where the order of their argument elements or result is not significant, and that duplicate values are not significant. Its default value has zero tuples. Note that, for any given Set subtype, Foo, where its value attribute has a declared type of Bar, the type Foo can be considered the power set of the type Bar.
sys.std.Core.Type.DHSet
This is an enumeration data type. DHSet is the intersection type of Set and DHRelation. The cardinality of this type is infinite.
sys.std.Core.Type.Maybe
This is an enumeration data type. Maybe is a proper subtype of Set where all member values may have at most one element; that is, it is a unary Relation with a nullary key. Operators that work specifically with Maybe subtypes can provide a syntactic shorthand for working with sparse data; so Muldis D has something which is conceptually close to SQL's nullable types without actually having 3-valued logic; it would probably be convenient for code that round-trips SQL by way of Muldis D to use the Maybe type. Its default value has zero tuples.
sys.std.Core.Type.DHMaybe
This is an enumeration data type. DHMaybe is the intersection type of Maybe and DHSet. The cardinality of this type is infinite.
The only member value of DHMaybe that has exactly zero elements is also known by the special name Maybe:nothing, aka nothing, aka empty set, aka ∅, which serves as the default value of the 4 types [|DH]Maybe and [|DH]Set. The single nothing value, which is a relation with zero tuples and a single attribute named value, is Muldis D's answer to the SQL NULL and is intended to be used for the same purposes; that is, a special marker for missing or inapplicable information, that does not typically equal any normal/scalar value; however, in Muldis D, nothing is a value, and it is equal to itself. To be more specific, the SQL NULL is very limited in what it actually can do, and can not be used to say anything other than "this isn't a normal value", similar to what Perl's "undef" says; if you want to actually indicate a reason why we don't have a normal value when more than one reason could possibly apply in the context, then using simply nothing or SQL's NULL can't do it, and instead you'll have to use other normal values such as status flags to keep the appropriate metadata.
sys.std.Core.Type.Single
This is an enumeration data type. Single is a proper subtype of Maybe where all member values have exactly 1 element. Its default value's only tuple's only attribute has the value Bool:false. The Single type consists of all of Maybe's values except nothing.
sys.std.Core.Type.DHSingle
This is an enumeration data type. DHSingle is the intersection type of Single and DHMaybe. Subtypes of DHSingle are also used to implement data-carrying database objects that are conceptually scalars rather than relations; for example, the current state of a sequence generator might typically be one. The cardinality of this type is infinite.
sys.std.Core.Type.Array
This is an enumeration data type. Array is a proper subtype of Relation that has 2 attributes, and their names are index and value, where index is a unary primary key and its declared type is a NNInt subtype (value can be non-unique and of any declared type). An Array is considered dense, and all index values in one are numbered consecutively from 0 to 1 less than the count of tuples, like array indices in typical programming languages. An Array subtype is normally used by any system-defined N-adic operators where the order of their argument elements or result is significant (and duplicate values are significant); specifically, index defines an explicit ordering for value. Its default value has zero tuples.
sys.std.Core.Type.DHArray
This is an enumeration data type. DHArray is the intersection type of Array and DHRelation. The cardinality of this type is infinite.
sys.std.Core.Type.Bag
This is an enumeration data type. Bag (or multiset) is a proper subtype of Relation that has 2 attributes, and their names are value and count, where value is a unary primary key (that can have any declared type) and count is a PInt subtype. A Bag subtype is normally used by any system-defined N-adic operators where the order of their argument elements or result is not significant, but that duplicate values are significant; specifically, count defines an explicit count of occurrences for value, also known as that value's multiplicity. Its default value has zero tuples.
sys.std.Core.Type.DHBag
This is an enumeration data type. DHBag is the intersection type of Bag and DHRelation. The cardinality of this type is infinite.
SYSTEM-DEFINED REFERENCE TYPES
These are the core reference data types.
sys.std.Core.Type.Reference
This is an enumeration data type. The Reference type is the maximal type of all Muldis D reference types. Its default value is a reference to the sys.std.Core.Type.Universal data type by way of its MaterialRef subtype. The cardinality of this type is infinity.
sys.std.Core.Type.External
This is a reference data type. An External is a reference within the Muldis D virtual machine to a value managed not by the Muldis D implementation but rather by a peer or host language in the wider program that includes the VM. All External values are treated as black boxes by Muldis D itself. The default value of this type is implementation-defined.
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.