Tuples

In pair.cecil:

The pair, triple, quadruple, and quintuple data structures can sometimes be useful, e.g., for returning a tuple of results from a function.

template object pair[T1,T2];
  extend type pair[`T1,`T2] subtypes pair[`S1 >= T1, `S2 >= T2];
  field first (@:pair[`T1,`T2]):T1;
  field second(@:pair[`T1,`T2]):T2;
  method pair(x:`T1, y:`T2):pair[T1,T2];
  method print_string(p@:pair[`T1,`T2]):string;
extend pair[`T1 <= comparable[T1], `T2 <= comparable[T2]]
        isa comparable[pair[T1,T2]];
  method =(p1@:pair[`T1 <= comparable[T1], `T2 <= comparable[T2]],
           p2@:pair[T1, T2]):bool;
extend pair[`T1 <= partially_ordered[T1], `T2 <= partially_ordered[T2]]
        isa partially_ordered[pair[T1,T2]];
  method <=(p1@:pair[`T1 <= partially_ordered[T1],
                     `T2 <= partially_ordered[T2]],
            p2@:pair[T1, T2]):bool;
  method <(p1@:pair[`T1 <= partially_ordered[T1],
                    `T2 <= partially_ordered[T2]],
           p2@:pair[T1, T2]):bool;
extend pair[`T1 <= hashable[T1], `T2 <= hashable[T2]]
        isa hashable[pair[T1,T2]];
  method hash(p@:pair[`T1 <= hashable[T1], `T2 <= hashable[T2]],
              range:int):int;
method <=_lex(q1@:pair[T1,T2], q2@:pair[T1,T2]):bool
                                        where ordered[`T1], ordered[`T2];

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, triples, quadruples, and quintuples do not start with new_ - like cons, they are exceptions from our naming convention for constructor methods.)

template object triple[T1,T2,T3];
  extend type triple[`T1,`T2,`T3]
        subtypes triple[`S1 >= T1, `S2 >= T2, `S3 >= T3];
  field signature first (triple[`T1,`T2,`T3]):T1;
  field signature second(triple[`T1,`T2,`T3]):T2;
  field third(@:triple[`T1,`T2,`T3]):T3;
  method triple(x:`T1, y:`T2, z:`T3):triple[T1,T2,T3];
  method print_string(p@:triple[`T1,`T2,`T3]):string;
extend triple[`T1 <= comparable[T1], `T2 <= comparable[T2],
              `T3 <= comparable[T3]]
        isa comparable[triple[T1,T2,T3]];
  method =(p1@:triple[`T1 <= comparable[T1],
                      `T2 <= comparable[T2],
                      `T3 <= comparable[T3]],
           p2@:triple[T1, T2, T3]):bool;
extend triple[`T1 <= partially_ordered[T1], `T2 <= partially_ordered[T2],
              `T3 <= partially_ordered[T3]]
        isa partially_ordered[triple[T1,T2,T3]];
  method <=(p1@:triple[`T1 <= partially_ordered[T1],
                       `T2 <= partially_ordered[T2],
                       `T3 <= partially_ordered[T3]],
            p2@:triple[T1, T2, T3]):bool;
extend triple[`T1 <= hashable[T1], `T2 <= hashable[T2], `T3 <= hashable[T3]]
        isa hashable[triple[T1,T2,T3]];
  method hash(p@:triple[`T1 <= hashable[T1],
                        `T2 <= hashable[T2],
                        `T3 <= hashable[T3]],
              range:int):int;
method <=_lex(q1@:triple[T1,T2,T3], q2@:triple[T1,T2,T3]):bool
                          where ordered[`T1], ordered[`T2], ordered[`T3];

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.

template object quadruple[T1,T2,T3,T4];
  extend type quadruple[`T1,`T2,`T3,`T4]
        subtypes quadruple[`S1 >= T1, `S2 >= T2, `S3 >= T3, `S4 >= T4];
  field signature first (quadruple[`T1,`T2,`T3,`T4]):T1;
  field signature second(quadruple[`T1,`T2,`T3,`T4]):T2;
  field signature third (quadruple[`T1,`T2,`T3,`T4]):T3;
  field fourth(@:quadruple[`T1,`T2,`T3,`T4]):T4;
  method quadruple(x:`T1, y:`T2, z:`T3, w:`T4):quadruple[T1,T2,T3,T4];
  method print_string(p@:quadruple[`T1,`T2,`T3,`T4]):string;
extend quadruple[`T1 <= comparable[T1], `T2 <= comparable[T2],
                 `T3 <= comparable[T3], `T4 <= comparable[T4]]
        isa comparable[quadruple[T1,T2,T3,T4]];
  method =(p1@:quadruple[`T1 <= comparable[T1],
                         `T2 <= comparable[T2],
                         `T3 <= comparable[T3],
                         `T4 <= comparable[T4]],
           p2@:quadruple[T1, T2, T3, T4]):bool;
extend quadruple[`T1 <= partially_ordered[T1], `T2 <= partially_ordered[T2],
                 `T3 <= partially_ordered[T3], `T4 <= partially_ordered[T4]]
        isa partially_ordered[quadruple[T1,T2,T3,T4]];
  method <=(p1@:quadruple[`T1 <= partially_ordered[T1],
                          `T2 <= partially_ordered[T2],
                          `T3 <= partially_ordered[T3],
                          `T4 <= partially_ordered[T4]],
            p2@:quadruple[T1, T2, T3, T4]):bool;
extend quadruple[`T1 <= hashable[T1], `T2 <= hashable[T2],
                 `T3 <= hashable[T3], `T4 <= hashable[T4]]
        isa hashable[quadruple[T1,T2,T3,T4]];
  method hash(p@:quadruple[`T1 <= hashable[T1], `T2 <= hashable[T2],
                           `T3 <= hashable[T3], `T4 <= hashable[T4]],
              range:int):int;
method <=_lex(q1@:quadruple[T1,T2,T3,T4], q2@:quadruple[T1,T2,T3,T4]):bool
          where ordered[`T1], ordered[`T2], ordered[`T3], ordered[`T4];

Quadruples are also provided.

template object quintuple[T1,T2,T3,T4,T5];
  extend type quintuple[`T1,`T2,`T3,`T4,`T5]
    subtypes quintuple[`S1 >= T1, `S2 >= T2, `S3 >= T3, `S4 >= T4, `S5 >= T5];
  field signature first (quintuple[`T1,`T2,`T3,`T4,`T5]):T1;
  field signature second(quintuple[`T1,`T2,`T3,`T4,`T5]):T2;
  field signature third (quintuple[`T1,`T2,`T3,`T4,`T5]):T3;
  field signature fourth(quintuple[`T1,`T2,`T3,`T4,`T5]):T4;
  field fifth(@:quintuple[`T1,`T2,`T3,`T4,`T5]):T5;
  method quintuple(x:`T1, y:`T2, z:`T3, w:`T4, v:`T5
                   ):quintuple[T1,T2,T3,T4,T5];
  method print_string(p@:quintuple[`T1,`T2,`T3,`T4,`T5]):string;
extend quintuple[`T1 <= comparable[T1], `T2 <= comparable[T2],
                 `T3 <= comparable[T3], `T4 <= comparable[T4],
                 `T5 <= comparable[T5]]
        isa comparable[quintuple[T1,T2,T3,T4,T5]];
  method =(p1@:quintuple[`T1 <= comparable[T1],
                         `T2 <= comparable[T2],
                         `T3 <= comparable[T3],
                         `T4 <= comparable[T4],
                         `T5 <= comparable[T5]],
           p2@:quintuple[T1, T2, T3, T4, T5]):bool;
extend quintuple[`T1 <= partially_ordered[T1], `T2 <= partially_ordered[T2],
                 `T3 <= partially_ordered[T3], `T4 <= partially_ordered[T4],
                 `T5 <= partially_ordered[T5]]
        isa partially_ordered[quintuple[T1,T2,T3,T4,T5]];
  method <=(p1@:quintuple[`T1 <= partially_ordered[T1],
                          `T2 <= partially_ordered[T2],
                          `T3 <= partially_ordered[T3],
                          `T4 <= partially_ordered[T4],
                          `T5 <= partially_ordered[T5]],
            p2@:quintuple[T1, T2, T3, T4, T5]):bool;
extend quintuple[`T1 <= hashable[T1], `T2 <= hashable[T2],
                 `T3 <= hashable[T3], `T4 <= hashable[T4],
                 `T5 <= hashable[T5]]
        isa hashable[quintuple[T1,T2,T3,T4,T5]];
  method hash(p@:quintuple[`T1 <= hashable[T1], `T2 <= hashable[T2],
                           `T3 <= hashable[T3], `T4 <= hashable[T4],
                           `T5 <= hashable[T5]],
              range:int):int;
method <=_lex(q1@:quintuple[T1,T2,T3,T4,T5],
              q2@:quintuple[T1,T2,T3,T4,T5]):bool
          where ordered[`T1], ordered[`T2], ordered[`T3], ordered[`T4],
                ordered[`T5];

Quintuples are also provided.