"An 8-bit byte. A `Byte` value represents a congruence class of [[integers|Integer]] modulo 256, and may be interpreted as: - an [[unsigned]] integer value in the range `0..255`, or - a [[signed]] integer value in the range `-128..127`. `Byte` is not considered a full numeric type, supporting only: - [[bitwise|Binary]] operations, and - addition and subtraction modulo 256. `Byte`s with modular addition form a [[mathematical group|Invertible]]. 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|Enumerable]]. 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|Comparable]] because any such order would: - be inconsistent with the definition of [[successor]] and [[predecessor]] under modular addition, and - would depend on interpretation of the `Byte` value as signed or unsigned. 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]]." tagged("Basic types") shared native final class Byte(congruent) extends Object() satisfies Binary<Byte> & Invertible<Byte> & Enumerable<Byte> { "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" Integer congruent; //shared [Boolean, Boolean, Boolean, Boolean, Boolean, Boolean, Boolean, Boolean] bits; "Whether this byte is even." shared native Boolean even; "Whether this byte is zero." shared native Boolean zero; "Whether this byte is one." shared native Boolean unit; "This byte interpreted as an unsigned integer in the range `0..255`." shared native Integer unsigned; "This byte interpreted as a signed integer in the range `-128..127`." shared native Integer signed; "The additive inverse of this byte. For any integer `x`: (-x.byte).signed = -x.byte.signed" shared actual native Byte negated; "The modulo 256 sum of this byte and the given byte." shared actual native Byte plus(Byte other); shared actual native Byte and(Byte other); shared actual native Byte flip(Integer index); shared actual native Boolean get(Integer index); shared actual native Byte leftLogicalShift(Integer shift); shared actual native Byte not; shared actual native Byte or(Byte other); shared actual native Byte rightArithmeticShift(Integer shift); shared actual native Byte rightLogicalShift(Integer shift); shared actual native Byte set(Integer index, Boolean bit); shared actual native Byte xor(Byte other); shared actual native Byte predecessor; shared actual native Byte successor; shared actual native Byte neighbour(Integer offset); shared actual native Integer offset(Byte other); shared actual native Integer offsetSign(Byte other); shared actual native Boolean equals(Object that); shared actual native Integer hash; "The [[unsigned]] interpretation of this byte as a string." shared actual native String string; }