```"Abstraction of types that are conceptually a sequence of
bits, and may be the subject of bitwise operations. A bit
is a [[Boolean]] value. Bits are indexed from right to
left, where `0` is the index of the least significant bit."
see (`class Integer`)
by ("Stef")
shared interface Binary<Other> of Other
given Other satisfies Binary<Other> {

"The binary complement of this sequence of bits."
shared formal Other not;

"Shift the sequence of bits to the left, by the given
[[number of places|shift]], filling the least
significant bits with zeroes (zero extension)."
shared formal Other leftLogicalShift(Integer shift);

"Shift the sequence of bits to the right, by the given
[[number of places|shift]], filling the most
significant bits with zeroes (zero extension).

If the sequence of bits represents a signed integer,
the sign is not preserved."
shared formal Other rightLogicalShift(Integer shift);

"Shift the sequence of bits to the right, by the given
[[number of places|shift]], preserving the values of
the most significant bits (sign extension).

If the sequence of bits represents a signed integer,
the sign is preserved."
shared formal Other rightArithmeticShift(Integer shift);

"Performs a logical AND operation."
shared formal Other and(Other other);

"Performs a logical inclusive OR operation."
shared formal Other or(Other other);

"Performs a logical exclusive OR operation."
shared formal Other xor(Other other);

"Retrieves a given bit from this bit sequence if
`0 <= index < size`, otherwise returns false."
shared formal Boolean get(Integer index);

"Returns an instance with the given bit set to the given
value if `0 <= index < size`, otherwise returns a value
with the same bits as this value."
shared formal Other set(Integer index, Boolean bit = true);

"Returns an instance with the given bit set to 0 if
`0 <= index < size`, otherwise returns a value with the
same bits as this value."
shared default Other clear(Integer index)
=> set(index, false);

"Returns an instance with the given bit flipped to its
opposite value if `0 <= index < size`, otherwise
returns a value with the same bits as this value."
shared formal Other flip(Integer index);
}

```