    "Given two streams, form a new stream consisting of all
     [[entries|Entry]] where, for any given index in the
     resulting stream, the [[key|Entry.key]] of the entry is the
     element occurring at the same index in the
     [[first stream|keys]], and the [[item|Entry.item]] is the
     element occurring at the same index in the
     [[second stream|items]]. The length of the resulting stream
     is the length of the shorter of the two given streams.

     Thus:

         zipEntries(keys, items)[i] == keys[i] -> items[i]

     for every `0<=i<smallest(keys.size,items.size)`."
    tagged("Streams")
    shared Iterable<<Key->Item>,KeyAbsent|ItemAbsent>
    zipEntries<Key,Item,KeyAbsent,ItemAbsent>
            (Iterable<Key,KeyAbsent> keys,
             Iterable<Item,ItemAbsent> items)
            given Key satisfies Object
            given KeyAbsent satisfies Null
            given ItemAbsent satisfies Null
            => mapPairs(Entry<Key,Item>, keys, items);

    "Given two streams, form a new stream consisting of all
     pairs where, for any given index in the resulting stream,
     the first element of the pair is the element occurring at
     the same index in the [[first stream|firstElements]], and
     the second element of the pair is the element occurring at
     the same index in the [[second stream|secondElements]]. The
     length of the resulting stream is the length of the shorter
     of the two given streams.

     Thus:

         zipPairs(xs, ys)[i] == [xs[i], ys[i]]

     for every `0<=i<smallest(xs.size,ys.size)`."
    tagged("Streams")
    shared Iterable<[First,Second],FirstAbsent|SecondAbsent>
    zipPairs<First,Second,FirstAbsent,SecondAbsent>
            (Iterable<First,FirstAbsent> firstElements,
             Iterable<Second,SecondAbsent> secondElements)
            given FirstAbsent satisfies Null
            given SecondAbsent satisfies Null
            => mapPairs((First first,Second second) => [first,second],
                    firstElements, secondElements);

    "Given a stream of values, and a stream of [[tuples|Tuple]],
     produce a new stream of tuples formed by prepending the
     values in the [[first stream|heads]] to the tuples in the
     [[second stream|tails]]. The length of the resulting stream
     is the length of the shorter of the two given streams.

     Thus:

         zip(heads, tails)[i] == [heads[i], *tails[i]]

     for every `0<=i<smallest(heads.size,tails.size)`."
    tagged("Streams")
    shared Iterable<Tuple<Element|Head,Head,Tail>,HeadAbsent|TailAbsent>
    zip<Element,Head,Tail,HeadAbsent,TailAbsent>
            (Iterable<Head,HeadAbsent> heads,
             Iterable<Tail,TailAbsent> tails)
            given Tail satisfies Element[]
            given HeadAbsent satisfies Null
            given TailAbsent satisfies Null
            => mapPairs(Tuple<Element|Head,Head,Tail>, heads, tails);