next up previous index
Next: Control structures Up: Basic data types and Previous: Options   Index

Tuples

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.

extend module Stdlib;
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
end module Pair;
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];
end module Triple;
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];
end module Quadruple;
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];
end module Quintuple;


next up previous index
Next: Control structures Up: Basic data types and Previous: Options   Index

Cecil/Vortex Project