An 8-bit byte. A Byte value represents a congruence class of integers 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 operations, and
  • addition and subtraction modulo 256.

Bytes 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:

  • 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.

Bytes are useful mainly because they can be efficiently stored in an Array.

no subtypes hierarchy

Byte(Integer congruent)
  • 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
evenshared Boolean even

Whether this byte is even.

hashshared 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
negatedshared actual Byte negated

The additive inverse of this byte. For any integer x:

(-x.byte).signed = -x.byte.signed
notshared actual Byte not

The binary complement of this sequence of bits.

Refines Binary.not
predecessorshared actual Byte predecessor

The predecessor of this value.

Refines Enumerable.predecessor ultimately refines Ordinal.predecessor
signedshared Integer signed

This byte interpreted as a signed integer in the range -128..127.

stringshared actual String string

The unsigned interpretation of this byte as a string.

successorshared actual Byte successor

The successor of this value.

Refines Enumerable.successor ultimately refines Ordinal.successor
unitshared Boolean unit

Whether this byte is one.

unsignedshared Integer unsigned

This byte interpreted as an unsigned integer in the range 0..255.

zeroshared Boolean zero

Whether this byte is zero.

Inherited Attributes
Attributes inherited from: Object
Attributes inherited from: Binary<Other>
Attributes inherited from: Enumerable<Other>
Attributes inherited from: Invertible<Other>
Attributes inherited from: Ordinal<Other>
andshared actual Byte and(Byte other)

Performs a logical AND operation.

Refines Binary.and
equalsshared 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.

flipshared 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
getshared actual Boolean get(Integer index)

Retrieves a given bit from this bit sequence if 0 <= index < size, otherwise returns false.

Refines Binary.get
leftLogicalShiftshared 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.

neighbourshared 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.
offsetshared 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.
offsetSignshared actual Integer offsetSign(Byte other)

The sign of the offset from the given value.

orshared actual Byte or(Byte other)

Performs a logical inclusive OR operation.

Refines Binary.or
plusshared actual Byte plus(Byte other)

The modulo 256 sum of this byte and the given byte.

rightArithmeticShiftshared 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.

rightLogicalShiftshared 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.

setshared 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
xorshared actual Byte xor(Byte other)

Performs a logical exclusive OR operation.

Refines Binary.xor
Inherited Methods
Methods inherited from: Object
Methods inherited from: Binary<Other>
Methods inherited from: Enumerable<Other>
Methods inherited from: Invertible<Other>
Methods inherited from: Summable<Other>