"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);
}
​
​