 NAME
 VERSION
 PREFACE
 DESCRIPTION
 TYPE SUMMARY
 MAXIMAL AND MINIMAL DATA TYPES
 GENERIC MIXIN DATA TYPES
 GENERIC SCALAR DATA TYPES
 sys.std.Core.Type.Scalar
 sys.std.Core.Type.DHScalar
 sys.std.Core.Type.Bool
 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.Rat
 sys.std.Core.Type.NNRat
 sys.std.Core.Type.PRat
 sys.std.Core.Type.Blob
 sys.std.Core.Type.OctetBlob
 sys.std.Core.Type.Text
 sys.std.Core.Type.Text.Unicode
 sys.std.Core.Type.Text.Unicode.Canon
 sys.std.Core.Type.Text.Unicode.Compat
 sys.std.Core.Type.Text.ASCII
 sys.std.Core.Type.Text.Latin1
 GENERIC NONSCALAR DATA TYPES
 sys.std.Core.Type.Tuple
 sys.std.Core.Type.DHTuple
 sys.std.Core.Type.Database
 sys.std.Core.Type.Set.T
 sys.std.Core.Type.DHSet.T
 sys.std.Core.Type.Array.T
 sys.std.Core.Type.DHArray.T
 sys.std.Core.Type.Bag.T
 sys.std.Core.Type.DHBag.T
 sys.std.Core.Type.SPInterval
 sys.std.Core.Type.DHSPInterval
 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.Just
 sys.std.Core.Type.DHJust
 sys.std.Core.Type.Array
 sys.std.Core.Type.DHArray
 sys.std.Core.Type.Bag
 sys.std.Core.Type.DHBag
 sys.std.Core.Type.MPInterval
 sys.std.Core.Type.DHMPInterval
 GENERIC EXTERNAL DATA TYPES
 SEE ALSO
 AUTHOR
 LICENSE AND COPYRIGHT
 TRADEMARK POLICY
 ACKNOWLEDGEMENTS
NAME
Muldis::D::Outdated::Core::Types  Muldis D general purpose data types
VERSION
This document is Muldis::D::Outdated::Core::Types version 0.148.2.
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::Outdated::Core document before this current document, as that forms its own tree beneath a root document branch.
DESCRIPTION
These core data types are generalpurpose in nature and are intended for use in defining or working with normal user data.
TYPE SUMMARY
This section shows all the data types and data type factories described in this document, arranged in a type graph according to their proper subsupertype relationships. Since there are a number of types with multiple parents, those types may appear multiple times in the graph; moreover, the graph is displayed in multiple slices, some of which are different views of the same type relationships. As a notable exception, sys.std.Core.Type.Empty
is a proper subtype of all of the other types in this graph, but it is only shown once.
This graph slice shows all of the toplevel types as is relevant from the user's point of view:
sys.std.Core.Type.Universal
sys.std.Core.Type.Empty
sys.std.Core.Type.Scalar
sys.std.Core.Type.DHScalar
sys.std.Core.Type.Bool
sys.std.Core.Type.Int
sys.std.Core.Type.Rat
sys.std.Core.Type.Blob
sys.std.Core.Type.Text
sys.std.Core.Type.Tuple
sys.std.Core.Type.DHTuple
sys.std.Core.Type.Database
sys.std.Core.Type.Relation
sys.std.Core.Type.DHRelation
sys.std.Core.Type.External
This arrangement is usersignificant for 2 main reasons. The first reason is that general semantics and intended interpretations of values and types fall into 4 main lines, represented by ScalarTupleRelationExternal
. The second reason is that only values of the 3 deeplyhomogeneous types shown above (DH[ScalarTupleRelation]
) may be used in a database; all values not of those types may only be used transiently. The fact that Int
is atomic while the other scalar types aren't is not relevant to users in the general case.
This graph slice shows all of those same toplevel types, plus a few more, as is relevant from the implementer's point of view:
sys.std.Core.Type.Universal
sys.std.Core.Type.Int
sys.std.Core.Type.Cat.List
sys.std.Core.Type.Cat.Structure
sys.std.Core.Type.Cat.String
sys.std.Core.Type.Tuple
sys.std.Core.Type.DHTuple
sys.std.Core.Type.Database
sys.std.Core.Type.Relation
sys.std.Core.Type.DHRelation
sys.std.Core.Type.Cat.ScalarWP
sys.std.Core.Type.Cat.DHScalarWP
sys.std.Core.Type.Bool
sys.std.Core.Type.Rat
sys.std.Core.Type.Blob
sys.std.Core.Type.Text
sys.std.Core.Type.External
sys.std.Core.Type.Cat.Nonstructure
This arrangement is implementersignificant because it best illustrates the conceptual implementation of the types; Int
and List
are the only 2 types that actually introduce values into the type system, and all other types are subset and/or union types composing their values; so, every Muldis D value either is an Int
or is a List
. The fact that Scalar
composes both Int
and List
values while TupleRelationExternal
compose only List
values is less important.
This graph slice shows all of the generalpurpose systemdefined scalar types:
sys.std.Core.Type.Universal
sys.std.Core.Type.Scalar
sys.std.Core.Type.Cat.ScalarWP
sys.std.Core.Type.Cat.DHScalarWP
sys.std.Core.Type.DHScalar
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.Cat.String
sys.std.Core.Type.Cat.DHScalarWP
sys.std.Core.Type.Bool
sys.std.Core.Type.Bool.*
sys.std.Core.Type.Rat
sys.std.Core.Type.NNRat
sys.std.Core.Type.PRat
sys.std.Core.Type.Blob
sys.std.Core.Type.OctetBlob
sys.std.Core.Type.Text
sys.std.Core.Type.Text.Unicode
sys.std.Core.Type.Text.Unicode.Canon
sys.std.Core.Type.Text.Unicode.Compat
sys.std.Core.Type.Text.ASCII
sys.std.Core.Type.Text.Latin1
To be clear, ScalarWP
is the intersection type of List
and Scalar
, and DHScalarWP
is the intersection type of ScalarWP
and DHScalar
; or, Scalar
is the union type of just Int
, String
and ScalarWP
, and DHScalar
is the union type of just Int
, String
and DHScalarWP
.
This graph slice shows all of the generalpurpose systemdefined nonscalar type factories:
sys.std.Core.Type.Universal
sys.std.Core.Type.Cat.List
sys.std.Core.Type.Cat.Structure
sys.std.Core.Type.Tuple
sys.std.Core.Type.DHTuple
sys.std.Core.Type.Database
sys.std.Core.Type.Set.T
sys.std.Core.Type.DHSet.T
sys.std.Core.Type.Array.T
sys.std.Core.Type.DHArray.T
sys.std.Core.Type.Bag.T
sys.std.Core.Type.DHBag.T
sys.std.Core.Type.SPInterval
sys.std.Core.Type.DHSPInterval
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.Just
sys.std.Core.Type.DHJust
sys.std.Core.Type.Array
sys.std.Core.Type.DHArray
sys.std.Core.Type.Bag
sys.std.Core.Type.DHBag
sys.std.Core.Type.MPInterval
sys.std.Core.Type.DHMPInterval
This graph slice shows all of those same nonscalar types, with a different view of their relationships:
sys.std.Core.Type.Universal
sys.std.Core.Type.Cat.List
sys.std.Core.Type.Cat.Structure
sys.std.Core.Type.Tuple
sys.std.Core.Type.DHTuple
sys.std.Core.Type.Database
sys.std.Core.Type.DHSet.T
sys.std.Core.Type.DHArray.T
sys.std.Core.Type.DHBag.T
sys.std.Core.Type.DHSPInterval
sys.std.Core.Type.Set.T
sys.std.Core.Type.Array.T
sys.std.Core.Type.Bag.T
sys.std.Core.Type.SPInterval
sys.std.Core.Type.Relation
sys.std.Core.Type.DHRelation
sys.std.Core.Type.DHSet
sys.std.Core.Type.DHMaybe
sys.std.Core.Type.DHJust
sys.std.Core.Type.DHArray
sys.std.Core.Type.DHBag
sys.std.Core.Type.DHMPInterval
sys.std.Core.Type.Set
sys.std.Core.Type.Maybe
sys.std.Core.Type.Just
sys.std.Core.Type.Array
sys.std.Core.Type.Bag
sys.std.Core.Type.MPInterval
To be clear, all of the nonscalar DH
prefixed types except for DH[TupleRelation]
are intersection types of one of the latter two plus the samenamed types sans the prefix.
This graph slice shows all of the generalpurpose systemdefined types that compose any mixin types, shown grouped under the mixin types that they compose:
sys.std.Core.Type.Universal
sys.std.Core.Type.Ordered
sys.std.Core.Type.Rat
sys.std.Core.Type.Blob
sys.std.Core.Type.Text
sys.std.Core.Type.Ordinal
sys.std.Core.Type.Bool
sys.std.Core.Type.Int
sys.std.Core.Type.Numeric
sys.std.Core.Type.Int
sys.std.Core.Type.Rat
sys.std.Core.Type.Stringy
sys.std.Core.Type.Blob
sys.std.Core.Type.Array
sys.std.Core.Type.Textual
sys.std.Core.Type.Text
sys.std.Core.Type.Attributive
sys.std.Core.Type.Tuple
sys.std.Core.Type.Relation
sys.std.Core.Type.Collective
sys.std.Core.Type.Set
sys.std.Core.Type.Array
sys.std.Core.Type.Bag
sys.std.Core.Type.SPInterval
sys.std.Core.Type.MPInterval
MAXIMAL AND MINIMAL DATA TYPES
These core data types are special and are the only Muldis D types (except for sys.std.Core.Type.Cat.[ListStructure]
) that are neither just scalar nor nonscalar nor external nor nonstructure types. They are all systemdefined and it is impossible for users to define more types of this nature.
sys.std.Core.Type.Universal
The Universal
type is the maximal type of the entire Muldis D type system, and contains every value that can possibly exist. Every other (nonaliased) 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. Universal
is the nullarydomainintersection type. Considering the lowlevel type system, Universal
is the domainunion type of just the 2 types Int
and List
.
sys.std.Core.Type.Empty
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 (nonaliased) 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. Empty
is the nullarydomainunion type. Considering the lowlevel type system, Empty
is the domainintersection type of just the 2 types Int
and List
.
GENERIC MIXIN DATA TYPES
sys.std.Core.Type.Ordered
The Ordered
type is a mixin (union) type that is intended to be explicitly composed by all other types that are considered ordered. An ordered type is a type for which one can take all of its values and place them on a line such that each value is definatively considered before all of the values one one side and after all of the values on the other side. A typical ordered type is a scalar type, but notscalar types can also be ordered. Almost all systemdefined scalar types are also ordered types, including: Bool
, Int
, Rat
, Blob
, Text
. The cardinality of Ordered
is infinity. The default value of Ordered
is Bool:False
. The minimum and maximum values of Ordered
are Inf
and Inf
, respectively; these 2 values are special singleton scalar types that are canonically considered to be before and after, respectively, every other value of the Muldis D type system, regardless of whether those values are composed into an ordered type.
sys.std.Core.Type.Ordinal
The Ordinal
type is a mixin (union) type that is intended to be explicitly composed by all other types that are considered ordinal. An ordinal type is an ordered type for which one can take any one of its values and derive a definitive predecessor or successor value, iff the initial value isn't the first or last value on the line. Similarly, one can take any two values of an ordinal type and produce an ordered list of all of that value's types which are on the line between those two values. The Ordinal
type explicitly composes the Ordered
mixin type, and so every type which explicitly composes Ordinal
also implicitly composes Ordered
. Just a few systemdefined ordered types are also ordinal types, including: Bool
, Int
. A primary quality of a type that is ordered but not ordinal is that you can take any two values of that type and then find a third value of that type which lies between the first two on the line; by definition for an ordinal type, there is no third value between one of its values and that value's predecessor or successor value. The cardinality of Ordinal
is infinity; its default and minimum and maximum values are the same as those of Ordered
.
For some ordinal types, there is the concept of a quantum or step size, where every consecutive pair of values on that type's value line are conceptually spaced apart at equal distances; this distance would be the quantum, and all steps along the value line are at exact multiples of that quantum. However, ordinal types in general don't need to be like this, and there can be different amounts of conceivable distance between consecutive values; an ordinal type is just required to know where all the values are.
sys.std.Core.Type.Numeric
The Numeric
type is a mixin (union) type that is intended to be explicitly composed by all other types that are considered numeric. A numeric type is a type with whose values it would be reasonable to apply all of the common mathematical operators like +
, 
, *
, /
. Just a few primary systemdefined types are numeric types, including Int
and Rat
. The cardinality of Numeric
is infinity. The default value of Numeric
is the Int
value zero. The Numeric
type is not itself ordered, but often a type which is numeric is also ordered. Muldis D does not currently have any systemdefined complex number types, but if it did, they conceivably would also compose Numeric
; but in that case, it may prove useful to split the Numeric
mixin into itself and a Real
mixin.
sys.std.Core.Type.Stringy
The Stringy
type is a mixin (union) type that is intended to be explicitly composed by all other types that are considered stringy, which for the moment also includes any types whose values are an ordered collection of elements, such as arrays. A stringy type is a type with whose values it would be reasonable to apply all of the common string or array operators like ~
or ~#
. Just a few primary systemdefined types are stringy types, including Blob
, Text
, and Array
. The cardinality of Stringy
is infinity. The default value of Stringy
is the Text
value empty string. The Stringy
type is not itself ordered, but often a type which is stringy is also ordered.
sys.std.Core.Type.Textual
The Textual
type is a mixin (union) type that is intended to be explicitly composed by all other types that are considered textual, that is those types whose values are strings of characters. The Textual
type explicitly composes the Stringy
mixin type, and so every type which explicitly composes Textual
also implicitly composes Stringy
. Most existing or likely systemdefined stringy types are also textual types, including Text
. The cardinality of Textual
is infinity. The default value of Textual
is the Text
value empty string. The Textual
type is not itself ordered, but often a type which is textual is also ordered.
sys.std.Core.Type.Attributive
The Attributive
type is a mixin (union) type that is intended to be explicitly composed by other types that are considered to be collections of named attributes, such as generic tuples and relations. Just a few primary systemdefined types are attributive types, namely Tuple
and Relation
. The cardinality of Attributive
is infinity. The default value of Attributive
is Tuple:D0
. The ScalarWP
type could conceivably compose Attributive
as well, but for now it doesn't, because it still differs from Tuple
and Relation
in several ways such that virtual routines composed for Tuple
and Relation
would be impractical to compose for ScalarWP
in general, but that might change later.
sys.std.Core.Type.Collective
The Collective
type is a mixin (union) type that is intended to be explicitly composed by other types that are effectively simple homogeneous collections of values, and something more specific than relations in general. Just a few primary systemdefined types are collective types, including Set
, Array
, Bag
, SPInterval
, and MPInterval
. The cardinality of Collective
is infinity. The default value of Collective
is Nothing
.
GENERIC 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::Outdated::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 metadata if the host language is more weakly typed or lacks onetoone type correspondence; see Muldis::D::Outdated::Dialect::HDMD_Perl6_STD or Muldis::D::Outdated::Dialect::HDMD_Perl5_STD for a Perl 65based example. These types, except for Scalar
and DHScalar
, are all ordered.
sys.std.Core.Type.Scalar
The Scalar
type is the maximal type of all Muldis D scalar types, and contains every scalar value that can possibly exist. Every other (nonaliased) 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. Considering the lowlevel type system, Scalar
is just the union type of these 3 types: Int
, String
, ScalarWP
.
sys.std.Core.Type.DHScalar
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 dhscalar 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 dhscalar types, and contains every dhscalar value that can possibly exist. Every other (nonaliased) dhscalar type is implicitly a proper subtype of DHScalar
, and DHScalar
is implicitly a union type over all other dhscalar types. Its default value is Bool:False
. The cardinality of this type is infinity. Considering the lowlevel type system, Scalar
is just the union type of these 3 types: Int
, String
, DHScalarWP
.
sys.std.Core.Type.Bool
The Bool
type is explicitly defined as a union type over just these 2 singleton types having sys.std.Core.Type.Bool.*
format names: False
and True
. A Bool
represents a truth value, and is the result type of any is_same
or is_not_same
routine; it is the only essential generalpurpose scalar data type of a generic D language, although not the only essential one in Muldis D. The default and minimum value of Bool
is False
; its maximum value is True
. The cardinality of this type is 2. The Bool
type explicitly composes the Ordinal
mixin type, and by extension also implicitly composes the Ordered
mixin type. The Bool
type has a default ordering algorithm that corresponds directly to the sequence in which its values are documented here; False
is ordered before True
.
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.Bool.*
There are exactly 2 types having sys.std.Core.Type.Bool.*
format names; for the rest of this description, the type name Bool.Value
will be used as a proxy for each and every one of them. A Bool.Value
has 1 systemdefined possrep whose name is the empty string and which has zero attributes. The cardinality of this type is 1, and its only value is its default and minimum and maximum value.
sys.std.Core.Type.Int
An Int
is a single exact integral number of any magnitude. The Int
type explicitly composes the Numeric
mixin type. Its default value is zero; its minimum and maximum values are conceptually infinities and practically impossible. Int
is one of just two scalar root types (the other is String
) that do not have any possreps. Int
is also the only atomic type in the Muldis D type system. The cardinality of this type is infinity; to define a mostgeneralized finite Int
subtype, you must specify the 2 integer endpoints of the inclusive range that all its values are in. The Int
type explicitly composes the Ordinal
mixin type, and by extension also implicitly composes the Ordered
mixin type. 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
NNInt
(nonnegative 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
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
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.Rat
A Rat
(scalar) is a single exact rational number of any magnitude and precision. The Rat
type explicitly composes the Numeric
mixin type. It is conceptually a composite type with 2 main systemdefined 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 rationaldividing 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 mostgeneralized finite Rat
subtype, you must specify the greatest magnitude value denominator, plus the 2 integer endpoints 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 endpoints 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 explicitly composes the Ordered
mixin type. 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
NNRat
(nonnegative 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
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.Blob
A Blob
is an undifferentiated string of bits. The Blob
type explicitly composes the Stringy
mixin type. A Blob
has 1 systemdefined 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. The Blob
type explicitly composes the Ordered
mixin type. 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
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). OctetBlob
adds 1 systemdefined 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 lowestelementindexed 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 highestelementindeed bit corresponds to the lowest bit of the octet. The reason the OctetBlob
type is systemdefined 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
A Text
is a string of abstract characters. The Text
type explicitly composes the Textual
mixin type, and by extension also implicitly composes the Stringy
mixin type. A Text
has 1 systemdefined possrep named maximal_chars
which consists of 1 String
typed attribute whose name is the empty string; each element of maximal_chars
is an integer representing an abstract character codepoint of an infinitesize proprietary abstract character repertoire, with each unique integer corresponding to a unique character. The Text
type explicitly composes the Ordered
mixin type. A Text
is a simple wrapper for a String
and all of its other details such as default and minimum and maximum values and cardinality and default ordering algorithm (matching and sorting is numeric by codepoint integer) all correspond directly. But Text
is explicitly disjoint from String
due to having a different intended interpretation. The formal definition of the Text
type does not define any abstract characters itself. Rather, the actual abstract characters in Text
's repertoire are all defined by the proper subtypes of Text
that each formally declare a character set, and the union of these is the repertoire of Text
; how such a said proper subtype declares a character set is by adding at least one possrep capable of representing strings of characters of that set. The set of such subtypes of Text
would collectively define mappings between their own possreps and maximal_chars
, either directly or indirectly. The Text
type is officially compatible with the Unicode standard version 6.2.0, and so all proper subtypes of Text
may only define character sets whose common characters with Unicode would cleanly map bidirectionally with the latter; most well known character sets do this, but for any others, they would be defined as some Textual
composing type that is disjoint from Text
. TODO: Investigate on what side of the fence Unicode alternatives such as ISO/IEC 2022 or Mojikyo or HKSCS would fall. Officially the actual integer strings used by maximal_chars
for abstract characters is both implementationdefined and unstable, so user code should typically never reference this possrep directly; similarly, the natural ordering of Text
is officially implementationdefined and unstable. The official way to have character string types that naturally sort in a way that is correct for some particular nationality is by having a disjoint Textual
composing type with a Text
typed possrep attribute and the wrapper type would define the desired ordering algorithm itself. Similarly, any concept of nationalityspecific graphemes is best expressed in a wrapper. Text
is more agnostic and generic in these matters. It is likely each implementation will make maximal_chars
resemble the largest well known character set that it knows about, typically Unicode. TODO: Consider making maximal_chars
formally identical to Unicode for all element integers in 0..2^21, and to ASCII for all in 0..127, and then the subtypes could be defined in a normal and independent/portable way. Maybe we need to formally define what higher ranges HKSCS/etc map to.
sys.std.Core.Type.Text.Unicode
Text.Unicode
is a proper subtype of Text
where all member values have just the abstract characters in the character repertoire of the Unicode standard version 6.2.0; the integer codepoint space that Unicode reserves for itself is 0..0x10FFFF, of which it currently has about 10% allocated. Text.Unicode
adds the 1 systemdefined possrep named unicode_codes
which consists of 1 String
typed attribute whose name is the empty string; each element of unicode_codes
represents a Unicode standard version 6.2.0 character abstract codepoint number. Text.Unicode
values in general do not conform to any Unicode normal form, so the same string can contain graphemes in both composed and decomposed formats, and two strings with the same graphemes in different such formats will compare as unequal. Text.Unicode
also adds the 1 systemdefined possrep named unicode_utf8_octets
which consists of 1 OString
typed attribute whose name is the empty string; unicode_utf8_octets
represents each codepoint as a sequence of 1..4 octets in the UTF8 encoding; the number of octets used varies by codepoint as follows: 1 for 0x0..0x7F, 2 for 0x80..0x7FF, 3 for 0x800..0xFFFF, 4 for 0x10000..0x10FFFF.
sys.std.Core.Type.Text.Unicode.Canon
Text.Unicode.Canon
is a proper subtype of Text.Unicode
where all member values are semantically in canonical decomposed normal form (NFD) and whose Text.Unicode
defined possreps are properly formatted NFD. Two Text.Unicode.Canon
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, and NFD is what the aforementioned possreps would format it in.
sys.std.Core.Type.Text.Unicode.Compat
Text.Unicode.Compat
is a proper subtype of Text.Unicode.Canon
where all member values are semantically in compatibility decomposed normal form (NFKD) and whose Text.Unicode
defined possreps are properly formatted NFKD. While typical applications would likely prefer Canon
, more securityconscious applications may likely prefer Compat
.
sys.std.Core.Type.Text.ASCII
Text.ASCII
is a proper subtype of Text.Unicode
(and of Text.Unicode.Compat
) where all member values have just the abstract characters in the 128character repertoire of 7bit ASCII. For these values, the unicode_codes
and unicode_utf8_octets
possreps have identical (OString
) attribute values, each element in which is in the range 0..127 inclusive. Text.ASCII
adds 1 systemdefined possrep named ascii_chars
which consists of 1 OString
typed attribute whose name is the empty string and whose value is identical to said other two possrep attribute values.
sys.std.Core.Type.Text.Latin1
Text.Latin1
is a proper subtype of Text.Unicode
(and a proper supertype of Text.ASCII
) where all member values have just the abstract characters in the 256character repertoire of 8bit ISO Latin 1 / ISO88591. Text.Latin1
adds 1 systemdefined possrep named latin1_chars
which consists of 1 OString
typed attribute whose name is the empty string and each of whose elements is a codepoint in the range 0..255 inclusive, and also doubles as the octet format of said codepoint in the Latin 1 encoding. The latin1_chars
and unicode_codes
possreps correspond as you might expect, such that both represent the same abstract characters using the appropriate codepoints of their repertoires.
GENERIC NONSCALAR DATA TYPES
These core nonscalar data types permit transparent/uservisible 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
The Tuple
type is the maximal type of all Muldis D tuple (nonscalar) types, and contains every tuple value that could possibly exist. The Tuple
type explicitly composes the Attributive
mixin type. 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 Nadic 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. Considering the lowlevel type system, Tuple
is just a proper subtype of Structure
consisting of every Structure
value whose first element is the Int
value 2
.
sys.std.Core.Type.DHTuple
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 dhtuple 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 dhtuple (dhnonscalar) types, and contains every dhtuple 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
Database
is a proper subtype of DHTuple
where all of its attributes are each of dhrelation types or of database types (the leaves of this recursion are all dhrelation types); it is otherwise the same. The 2 systemdefined userdata variables named [fednlx].data
are all of "just" the Database
type, or are of its proper subtypes.
sys.std.Core.Type.Set.T
Set.T
is a proper subtype of Tuple
, and it exists in order for the relation type Set
(and Maybe
and Just
) to be defined partly in terms of it. A Set.T
has 1 attribute, value
(a Universal
). Its default value a value
of Bool:False
.
sys.std.Core.Type.DHSet.T
DHSet.T
is the intersection type of Set.T
and DHTuple
, and it exists in order for the dhrelation type DHSet
(and DHMaybe
, DHJust
) to be defined partly in terms of it.
sys.std.Core.Type.Array.T
Array.T
is a proper subtype of Tuple
, and it exists in order for the relation type Array
to be defined partly in terms of it. An Array.T
has 2 attributes, index
(a NNInt
) and value
(a Universal
). Its default value has an index
of zero and a value
of Bool:False
.
sys.std.Core.Type.DHArray.T
DHArray.T
is the intersection type of Array.T
and DHTuple
, and it exists in order for the dhrelation type DHArray
to be defined partly in terms of it.
sys.std.Core.Type.Bag.T
Bag.T
is a proper subtype of Tuple
, and it exists in order for the relation type Bag
to be defined partly in terms of it. A Bag.T
has 2 attributes, value
(a Universal
) and count
(a PInt
). Its default value has a value
of Bool:False
and a count
of 1.
sys.std.Core.Type.DHBag.T
DHBag.T
is the intersection type of Bag.T
and DHTuple
, and it exists in order for the dhrelation type DHBag
to be defined partly in terms of it.
sys.std.Core.Type.SPInterval
An SPInterval
(singlepiece interval) is a Tuple
. The SPInterval
type explicitly composes the Collective
mixin type. It typically defines a single bounded interval/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. It can also define an unbounded interval/infinite interval, which is accomplished by using an infinity for either or both endpoint values.
An SPInterval
has these 4 attributes:
minmax
Universal

These are the interval endpoint values;
min
defines the leftstartfrom endpoint andmax
defines the rightendto endpoint. The endpoint values conceptually must be of the same, totallyordered type (typically one ofInt
,Rat
,Text
,TAIInstant
, etc), although strictly speaking they may be of any types at all; in the latter case, to actually make practical use of such intervals, anorderdetermination
function must explicitly be employed. excludes_[minmax]
Bool

If
excludes_min
orexcludes_max
areBool:True
, thenmin
ormax
is 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 SPInterval
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 SPInterval
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 situationdependent on what orderdetermination
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 orderdetermination
function, an SPInterval
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 SPInterval
values that are conceptually empty intervals, and the is_same
function should not be used to test an SPInterval
for being empty or not.
The SPInterval
type supports unbounded/infinite or halfbounded intervals that are orthogonal to data type. This feature is implemented using the 2 special singleton types Inf
and Inf
. Iff min
is Inf
then the interval is leftunbounded; iff max
is Inf
then the interval is rightunbounded. An interval that is unbounded on both ends is the maximal interval, in that all Muldis D values are members of it, at least in the general context lacking any orderdetermination
function.
The default value of SPInterval
represents an empty interval where its min
and max
attributes are Inf
and Inf
, respectively, and its other 2 attributes are Bool:False
.
See also the sys.std.Core.Type.MPInterval
type, which is the canonical means that Muldis D provides of representing the result of setunioning 2 SPInterval
where the latter do not touch or overlap, and provides the single canonical empty interval value.
sys.std.Core.Type.DHSPInterval
DHSPInterval
is a proper subtype of SPInterval
where every one of its values is also a DHTuple
. In general practice, all SPInterval
values are DHSPInterval
values, because their endpoints would all be DHScalar
values. The default value of DHSPInterval
is the same as that of SPInterval
.
sys.std.Core.Type.Relation
The Relation
type is the maximal type of all Muldis D relation (nonscalar) types, and contains every relation value that could possibly exist. The Relation
type explicitly composes the Attributive
mixin type. 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. Considering the lowlevel type system, Relation
is just a proper subtype of Structure
consisting of every Structure
value whose first element is the Int
value 3
.
sys.std.Core.Type.DHRelation
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 dhrelation 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 dhrelation's dhtuples' 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 dhrelation (dhnonscalar) types, and contains every dhrelation 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
Set
is a proper subtype of Relation
that has 1 attribute, and its name is value
; it can be of any declared type. The Set
type explicitly composes the Collective
mixin type. A Set
subtype is normally used by any systemdefined Nadic 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
DHSet
is the intersection type of Set
and DHRelation
. The cardinality of this type is infinite.
sys.std.Core.Type.Maybe
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 3valued logic; it would probably be convenient for code that roundtrips SQL by way of Muldis D to use the Maybe
type. Its default value has zero tuples.
sys.std.Core.Type.DHMaybe
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.Just
Just
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 Just
type consists of all of Maybe
's values except Nothing
.
sys.std.Core.Type.DHJust
DHJust
is the intersection type of Just
and DHMaybe
. Subtypes of DHJust
are also used to implement datacarrying 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
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 nonunique and of any declared type). The Array
type explicitly composes the Collective
mixin 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 systemdefined Nadic 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. The Array
type explicitly composes the Stringy
mixin type.
sys.std.Core.Type.DHArray
DHArray
is the intersection type of Array
and DHRelation
. The cardinality of this type is infinite.
sys.std.Core.Type.Bag
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. The Bag
type explicitly composes the Collective
mixin type. A Bag
subtype is normally used by any systemdefined Nadic 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
DHBag
is the intersection type of Bag
and DHRelation
. The cardinality of this type is infinite.
sys.std.Core.Type.MPInterval
MPInterval
(multipiece interval) is a proper subtype of Relation
that is defined directly partly in terms of the tuple type SPInterval
, thereby sharing its heading, but defines no further constraints of its own. The MPInterval
type explicitly composes the Collective
mixin type. It defines a single multipiece interval, which is conceptually either a set of 0..N intervals or a single larger interval that had 0..N subintervals sliced out. An MPInterval
is the canonical means that Muldis D provides of representing the result of setunioning 2 SPInterval
where the latter do not touch or overlap. Moreover, an MPInterval
also empowers Muldis D to have a single canonical empty interval value, which is the only MPInterval
with zero tuples; this value is also the default value of MPInterval
. The cardinality of this type is infinite.
sys.std.Core.Type.DHMPInterval
DHMPInterval
is the intersection type of MPInterval
and DHRelation
. The cardinality of this type is infinite.
GENERIC EXTERNAL DATA TYPES
sys.std.Core.Type.External
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 cardinality of this type is infinity. The default value of this type is implementationdefined. Considering the lowlevel type system, External
is just a proper subtype of Structure
consisting of every Structure
value whose first element is the Int
value 5
.
SEE ALSO
Go to Muldis::D for the majority of distributioninternal references, and Muldis::D::SeeAlso for the majority of distributionexternal references.
AUTHOR
Darren Duncan (darren@DarrenDuncan.net
)
LICENSE AND COPYRIGHT
This file is part of the formal specification of the Muldis D language.
Muldis D is Copyright © 20022011, 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.