Primitive Datatypes & undecomposable values
«Primitive datatypes are datatypes
whose values are regarded fundamental - not subject to any reduction. They
just "are". Those values are what some languages have called "atomic", or
"plain values". Many primitive datatypes are also generic, in the sense that
they have an unlimited number of values, and hence the datatypes often used in
practice are confined to a finite subset of them.» [TaxDT]
E.g.
Boolean, State, Enumerated (linear or cyclic enumeration
types), Character, Ordinal, Date-and-time, Integer, Rational, Scaled,
Real, Complex, Void.
«This is a much longer list than that which most languages
designate as "primitive" ... A simple example of such a represented datatype
is complex as an ordered pair of real numbers, the "real" and
"imaginary" parts. However, LID eschews this form of "representation" as well
as the more obvious bit-level form. A LID datatype is just a set of values,
and using the cartesian form to identify them is only a convenience for some
purposes - think of the polar form, for example.» [TaxDT]
There's more on two-valued
datatypes like boolean.
«The important thing is that the LIS [language independent
standard] leaves in no doubt that file descriptors are not integers, however
convenient it may be to represent them by integers.» [shortly
below the middle of "In defence of language-independent standards"]
| |
|
Aggregate Datatypes & decomposable values
«An aggregate datatype is one whose
values are made up of a number ... of component values, each of which is a
value of another datatype.» [TaxDT]
Other
aggregate datatypes are described by restricting the properties of its values,
i.e. of the aggregates (where the most general one is the bag):
Multiplicity of the same value as a component (e.g. Set vs. Bag).
Range of component candidates (e.g. Bag of Integers).
Number of components (e.g. Set size 1 to 10).
Ordering of components (e.g. Bag vs. Sequence).
Recursion in the structure (e.g. Sequence vs. Tree).
Distinction between components
by tags (e.g. Bag vs. Record),
by [externally or internally provided] keys from some datatype,
or by indices, i.e., external keys from an uninterrupted range of values (e.g. Vector).
Dimensions in the distinction of
components: Inherent multidimensionality: No ordering of dimensions,
and hence no general ordering of components (e.g. Array[1..10,1..10] of Int
can yield "row" Vectors and "column" Vectors by fixing one of the indices).
Induced multidimensionality: An aggregate datatype defined as an
aggregate of components which are themselves aggregates, but which are then
unpacked (e.g. Vector[1..10] of Vector[1..10] of Int).
| |
|
Generated Datatypes & undecomposable??? values
|
«The (non-aggregate) generated datatypes
in the taxonomy are pointer, procedure, and choice datatypes. Such datatypes
are produced from other datatypes by the methods familiar from languages that
include them ...» [TaxDT]
| |
|
"Subtypes" & no new values
[NB.: This use of "subtype" does not coincide with the terminology in OO and in type theory]
|
«In the taxonomy subtypes are created by
modifying the value-space of a "base" datatype in various ways - specifying a
range or size; selecting values; excluding values; extending the value-space;
or defining explicitly how the value-space is constructed from that of a
"base" datatype. ... [I]n the taxonomy any datatype can be used as the base,
not just the primitive ones, and in that context extension is a useful subtype
constructor e.g. you can make a new subtype by extending an existing
one.» [TaxDT]
| |
|
Derived Datatypes and datatype generators
«The taxonomy allows for new datatypes to be produced from existing ones (copies,
or "clones") and for further datatypes and datatype generators
to be derived from the basic primitive and generated ones» [TaxDT]
E.g. Tree (a recursive sequence), CharacterString, BitString, Bit, Modulo,
TimeInterval.
| | | | | |
