Next: Control structures
Up: Basic data types and
Previous: Options
Index
In pair.diesel:
The pair, triple, quadruple, and quintuple data
structures represent immutable tuples of values. They can be
compared iff their components can be.
A pair is an immutable pair of arbitrary values. A pair of
two types T1 and T2 is a subtype of pairs of any supertypes
S1 and S2, e.g., a pair of an integer and a set is a
subtype of a pair of a number and an unordered_collection
.
The pair method constructs a new pair. (The constructor
methods for pairs et al. do not start with new_
- like
cons, they are exceptions from our naming convention for
constructor methods.)
module Pair;
class pair[T1,T2] isa pair[`S1 >= T1, `S2 >= T2];
field first (:pair[`T1,`T2]):T1;
field second(:pair[`T1,`T2]):T2;
fun pair(x:`T1, y:`T2):pair[T1,T2]; - create a pair
extend class pair[`T1 <= comparable[T1], `T2 <= comparable[T2]]
isa comparable[pair[T1,T2]];
extend class pair[`T1 <= partially_ordered[T1],
`T2 <= partially_ordered[T2]]
isa partially_ordered_using_<=[pair[T1,T2]];
extend class pair[`T1 <= hashable[T1], `T2 <= hashable[T2]]
isa hashable[pair[T1,T2]];
fun <=_lex(p1:pair[`T11 <= `T1, `T12 <= `T2],
p2:pair[`T21 <= `T1, `T22 <= `T2]):bool
where `T1 <= ordered[T1], `T2 <= ordered[T2]; - lexicographical order
Triples are an immutable triple of arbitrary values. A triple of
three types T1, T2, and T3 is a subtype of triples of any
supertypes S1, S2, and S3. The triple method
constructs a new triple.
module Triple;
class triple[T1,T2,T3] isa triple[`S1 >= T1, `S2 >= T2, `S3 >= T3];
field first (:triple[`T1,`T2,`T3]):T1;
field second(:triple[`T1,`T2,`T3]):T2;
field third (:triple[`T1,`T2,`T3]):T3;
fun triple(x:`T1, y:`T2, z:`T3):triple[T1,T2,T3]; - create a triple
extend class triple[`T1 <= comparable[T1],
`T2 <= comparable[T2],
`T3 <= comparable[T3]]
isa comparable[triple[T1,T2,T3]];
extend class triple[`T1 <= partially_ordered[T1],
`T2 <= partially_ordered[T2],
`T3 <= partially_ordered[T3]]
isa partially_ordered_using_<=[triple[T1,T2,T3]];
extend class triple[`T1 <= hashable[T1],
`T2 <= hashable[T2],
`T3 <= hashable[T3]]
isa hashable[triple[T1,T2,T3]];
fun <=_lex(p1:triple[`T11 <= `T1, `T12 <= `T2, `T13 <= `T3],
p2:triple[`T21 <= `T1, `T22 <= `T2, `T23 <= `T3]):bool
where `T1 <= ordered[T1],
`T2 <= ordered[T2],
`T3 <= ordered[T3];
Quadruples are also provided.
module Quadruple;
class quadruple[T1,T2,T3,T4]
isa quadruple[`S1 >= T1, `S2 >= T2, `S3 >= T3, `S4 >= T4];
field first (:quadruple[`T1,`T2,`T3,`T4]):T1;
field second(:quadruple[`T1,`T2,`T3,`T4]):T2;
field third (:quadruple[`T1,`T2,`T3,`T4]):T3;
field fourth(:quadruple[`T1,`T2,`T3,`T4]):T4;
fun quadruple(x:`T1, y:`T2, z:`T3, w:`T4):quadruple[T1,T2,T3,T4]; - create a quadruple
extend class quadruple[`T1 <= comparable[T1],
`T2 <= comparable[T2],
`T3 <= comparable[T3],
`T4 <= comparable[T4]]
isa comparable[quadruple[T1,T2,T3,T4]];
extend class quadruple[`T1 <= partially_ordered[T1],
`T2 <= partially_ordered[T2],
`T3 <= partially_ordered[T3],
`T4 <= partially_ordered[T4]]
isa partially_ordered_using_<=[quadruple[T1,T2,T3,T4]];
extend class quadruple[`T1 <= hashable[T1],
`T2 <= hashable[T2],
`T3 <= hashable[T3],
`T4 <= hashable[T4]]
isa hashable[quadruple[T1,T2,T3,T4]];
fun <=_lex(p1:quadruple[`T11<=`T1, `T12<=`T2, `T13<=`T3, `T14<=`T4],
p2:quadruple[`T21<=`T1, `T22<=`T2, `T23<=`T3, `T24<=`T4]
):bool where `T1 <= ordered[T1],
`T2 <= ordered[T2],
`T3 <= ordered[T3],
`T4 <= ordered[T4];
Quintuples are also provided.
module Quintuple;
class quintuple[T1,T2,T3,T4,T5]
isa quintuple[`S1 >= T1, `S2 >= T2, `S3 >= T3, `S4 >= T4, `S5 >= T5];
field first (:quintuple[`T1,`T2,`T3,`T4,`T5]):T1;
field second(:quintuple[`T1,`T2,`T3,`T4,`T5]):T2;
field third (:quintuple[`T1,`T2,`T3,`T4,`T5]):T3;
field fourth(:quintuple[`T1,`T2,`T3,`T4,`T5]):T4;
field fifth (:quintuple[`T1,`T2,`T3,`T4,`T5]):T5;
fun quintuple(x:`T1, y:`T2, z:`T3, w:`T4, v:`T5
):quintuple[T1,T2,T3,T4,T5]; - create a quintuple
extend class quintuple[`T1 <= comparable[T1],
`T2 <= comparable[T2],
`T3 <= comparable[T3],
`T4 <= comparable[T4],
`T5 <= comparable[T5]]
isa comparable[quintuple[T1,T2,T3,T4,T5]];
extend class quintuple[`T1 <= partially_ordered[T1],
`T2 <= partially_ordered[T2],
`T3 <= partially_ordered[T3],
`T4 <= partially_ordered[T4],
`T5 <= partially_ordered[T5]]
isa partially_ordered_using_<=[quintuple[T1,T2,T3,T4,T5]];
extend class quintuple[`T1 <= hashable[T1],
`T2 <= hashable[T2],
`T3 <= hashable[T3],
`T4 <= hashable[T4],
`T5 <= hashable[T5]]
isa hashable[quintuple[T1,T2,T3,T4,T5]];
fun <=_lex(p1:quintuple[`T11<=`T1, `T12<=`T2, `T13<=`T3,
`T14<=`T4, `T15<=`T5],
p2:quintuple[`T21<=`T1, `T22<=`T2, `T23<=`T3,
`T24<=`T4, `T25<=`T5]
):bool where `T1 <= ordered[T1],
`T2 <= ordered[T2],
`T3 <= ordered[T3],
`T4 <= ordered[T4],
`T5 <= ordered[T5];
Next: Control structures
Up: Basic data types and
Previous: Options
Index
Cecil/Vortex Project