An 8-bit byte. A `Byte` value represents a congruence class of integers modulo 256, and may be interpreted as:

`Byte` is not considered a full numeric type, supporting only:

• bitwise operations, and
• addition and subtraction modulo 256.

`Byte`s with modular addition form a mathematical group. Thus, every byte `b` has an additive inverse `-b` where:

```(-b).signed == -b.signed
(-b).unsigned == b.unsigned==0 then 0 else 256 - b.unsigned
```

`Byte` is a recursive enumerable type. For example, the range:

```254.byte .. 1.byte
```

contains the values `254.byte, 255.byte, 0.byte, 1.byte`.

`Byte` does not have a total order because any such order would:

Thus, to compare the magnitude of two bytes, it is necessary to first convert them to either their `signed` or `unsigned` integer values.

`Byte`s are useful mainly because they can be efficiently stored in an `Array`.

• `Byte`
• `Binary`
• `Enumerable`
• `Ordinal`
• `Invertible`
• `Summable`
• `Object`
• `Anything`

no subtypes hierarchy

 Initializer `Byte(Integer congruent)`Parameters: `congruent`An integer member of the congruence class of the resulting `Byte`. For any integer `x>=0`: ```x.byte.unsigned == x % 256 x.byte.signed == x % 256 ``` And for an integer `x<0`: ```x.byte.unsigned == 256 + x % 256 x.byte.signed == x % 256 ``` And for any integers `x` and `y` which are congruent modulo 256: ```x.byte == y.byte ```
 Attributes `even` `shared Boolean even`Whether this byte is even. `hash` `shared actual Integer hash`The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that: if `x==y` then `x.hash==y.hash`. Therefore, a class which refines `Object.equals()` must also refine `hash`. Because the `Integer` type is platform-dependent a compiler for a given platform is permitted to further manipulate the calculated hash for an object, and the resulting hash may differ between platforms. Refines `Object.hash` `negated` `shared actual Byte negated`The additive inverse of this byte. For any integer `x`: ```(-x.byte).signed = -x.byte.signed ``` Refines `Invertible.negated` `not` `shared actual Byte not`The binary complement of this sequence of bits. Refines `Binary.not` `predecessor` `shared actual Byte predecessor`The predecessor of this value. Refines `Enumerable.predecessor` ultimately refines `Ordinal.predecessor` `signed` `shared Integer signed`This byte interpreted as a signed integer in the range `-128..127`. `string` `shared actual String string`The `unsigned` interpretation of this byte as a string. Refines `Object.string` `successor` `shared actual Byte successor`The successor of this value. Refines `Enumerable.successor` ultimately refines `Ordinal.successor` `unit` `shared Boolean unit`Whether this byte is one. `unsigned` `shared Integer unsigned`This byte interpreted as an unsigned integer in the range `0..255`. `zero` `shared Boolean zero`Whether this byte is zero.
 Inherited Attributes Attributes inherited from: `Object` Attributes inherited from: `Binary``not` Attributes inherited from: `Enumerable` Attributes inherited from: `Invertible``negated` Attributes inherited from: `Ordinal`
 Methods `and` `shared actual Byte and(Byte other)`Performs a logical AND operation. Refines `Binary.and` `equals` `shared actual Boolean equals(Object that)`Determine if two values are equal. Implementations should respect the constraints that: if `x===y` then `x==y` (reflexivity), if `x==y` then `y==x` (symmetry), if `x==y` and `y==z` then `x==z` (transitivity). Furthermore it is recommended that implementations ensure that if `x==y` then `x` and `y` have the same concrete class. A class which explicitly refines `equals()` is said to support value equality, and the equality operator `==` is considered much more meaningful for such classes than for a class which simply inherits the default implementation of identity equality from `Identifiable`. Refines `Object.equals` `flip` `shared actual Byte flip(Integer index)`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. Refines `Binary.flip` `get` `shared actual Boolean get(Integer index)`Retrieves a given bit from this bit sequence if `0 <= index < size`, otherwise returns false. Refines `Binary.get` `leftLogicalShift` `shared actual Byte leftLogicalShift(Integer shift)`Shift the sequence of bits to the left, by the given number of places, filling the least significant bits with zeroes. `neighbour` `shared actual Byte neighbour(Integer offset)`The indirect successor or predecessor at the given `offset`, where: `x.neighbour(0) == x`, `x.neighbour(i+1) == x.neighbour(i).successor`, and `x.neighbour(i-1) == x.neighbour(i).predecessor`. `offset` `shared actual Integer offset(Byte other)`Compute the offset from the given value, where: `x.offset(x) == 0`, and `x.successor.offset(x) == 1` if `x!=x.successor`. Refines `Enumerable.offset` `offsetSign` `shared actual Integer offsetSign(Byte other)`The sign of the offset from the given value. `or` `shared actual Byte or(Byte other)`Performs a logical inclusive OR operation. Refines `Binary.or` `plus` `shared actual Byte plus(Byte other)`The modulo 256 sum of this byte and the given byte. Refines `Summable.plus` `rightArithmeticShift` `shared actual Byte rightArithmeticShift(Integer shift)`Shift the sequence of bits to the right, by the given number of places, preserving the values of the most significant bits. If the sequence of bits represents a signed integer, the sign is preserved. `rightLogicalShift` `shared actual Byte rightLogicalShift(Integer shift)`Shift the sequence of bits to the right, by the given number of places, filling the most significant bits with zeroes. If the sequence of bits represents a signed integer, the sign is not preserved. `set` `shared actual Byte set(Integer index, Boolean bit)`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. Refines `Binary.set` `xor` `shared actual Byte xor(Byte other)`Performs a logical exclusive OR operation. Refines `Binary.xor`
 Inherited Methods Methods inherited from: `Object``equals()` Methods inherited from: `Binary` Methods inherited from: `Enumerable` Methods inherited from: `Invertible``minus()` Methods inherited from: `Summable``plus()`