Object aggregation

In pair.cecil:

The pair, triple, and quadruple 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;

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, and quadruples 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;

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;

Quadruples are also provided.