# Int8

8-bit signed integers with checked arithmetic

Most operations are available as built-in operators (e.g. `1 + 1`).

## toInt

``let toInt : Int8 -> Int``

Conversion.

## fromInt

``let fromInt : Int -> Int8``

Conversion. Traps on overflow/underflow.

## fromIntWrap

``let fromIntWrap : Int -> Int8``

Conversion. Wraps on overflow/underflow.

## fromNat8

``let fromNat8 : Nat8 -> Int8``

Conversion. Wraps on overflow/underflow.

## toNat8

``let toNat8 : Int8 -> Nat8``

Conversion. Wraps on overflow/underflow.

## toText

``func toText(x : Int8) : Text``

Returns the Text representation of `x`.

## abs

``func abs(x : Int8) : Int8``

Returns the absolute value of `x`. Traps when `x = -2^7`.

## min

``func min(x : Int8, y : Int8) : Int8``

Returns the minimum of `x` and `y`.

## max

``func max(x : Int8, y : Int8) : Int8``

Returns the maximum of `x` and `y`.

## equal

``func equal(x : Int8, y : Int8) : Bool``

Returns `x == y`.

## notEqual

``func notEqual(x : Int8, y : Int8) : Bool``

Returns `x != y`.

## less

``func less(x : Int8, y : Int8) : Bool``

Returns `x < y`.

## lessOrEqual

``func lessOrEqual(x : Int8, y : Int8) : Bool``

Returns `x ⇐ y`.

## greater

``func greater(x : Int8, y : Int8) : Bool``

Returns `x > y`.

## greaterOrEqual

``func greaterOrEqual(x : Int8, y : Int8) : Bool``

Returns `x >= y`.

## compare

``func compare(x : Int8, y : Int8) : {#less; #equal; #greater}``

Returns the order of `x` and `y`.

## neg

``func neg(x : Int8) : Int8``

Returns the negation of `x`, `-x`. Traps on overflow.

``func add(x : Int8, y : Int8) : Int8``

Returns the sum of `x` and `y`, `x + y`. Traps on overflow.

## sub

``func sub(x : Int8, y : Int8) : Int8``

Returns the difference of `x` and `y`, `x - y`. Traps on underflow.

## mul

``func mul(x : Int8, y : Int8) : Int8``

Returns the product of `x` and `y`, `x * y`. Traps on overflow.

## div

``func div(x : Int8, y : Int8) : Int8``

Returns the division of `x by y`, `x / y`. Traps when `y` is zero.

## rem

``func rem(x : Int8, y : Int8) : Int8``

Returns the remainder of `x` divided by `y`, `x % y`. Traps when `y` is zero.

## pow

``func pow(x : Int8, y : Int8) : Int8``

Returns `x` to the power of `y`, `x ** y`. Traps on overflow.

## bitnot

``func bitnot(x : Int8, y : Int8) : Int8``

Returns the bitwise negation of `x`, `^x`.

## bitand

``func bitand(x : Int8, y : Int8) : Int8``

Returns the bitwise and of `x` and `y`, `x & y`.

## bitor

``func bitor(x : Int8, y : Int8) : Int8``

Returns the bitwise or of `x` and `y`, `x \| y`.

## bitxor

``func bitxor(x : Int8, y : Int8) : Int8``

Returns the bitwise exclusive or of `x` and `y`, `x ^ y`.

## bitshiftLeft

``func bitshiftLeft(x : Int8, y : Int8) : Int8``

Returns the bitwise shift left of `x` by `y`, `x << y`.

## bitshiftRight

``func bitshiftRight(x : Int8, y : Int8) : Int8``

Returns the bitwise shift right of `x` by `y`, `x >> y`.

## bitrotLeft

``func bitrotLeft(x : Int8, y : Int8) : Int8``

Returns the bitwise rotate left of `x` by `y`, `x <<> y`.

## bitrotRight

``func bitrotRight(x : Int8, y : Int8) : Int8``

Returns the bitwise rotate right of `x` by `y`, `x <>> y`.

## bittest

``func bittest(x : Int8, p : Nat) : Bool``

Returns the value of bit `p mod 8` in `x`, `(x & 2^(p mod 8)) == 2^(p mod 8)`.

## bitset

``func bitset(x : Int8, p : Nat) : Int8``

Returns the value of setting bit `p mod 8` in `x` to `1`.

## bitclear

``func bitclear(x : Int8, p : Nat) : Int8``

Returns the value of clearing bit `p mod 8` in `x` to `0`.

## bitflip

``func bitflip(x : Int8, p : Nat) : Int8``

Returns the value of flipping bit `p mod 8` in `x`.

## bitcountNonZero

``let bitcountNonZero : (x : Int8) -> Int8``

Returns the count of non-zero bits in `x`.

``let bitcountLeadingZero : (x : Int8) -> Int8``

Returns the count of leading zero bits in `x`.

## bitcountTrailingZero

``let bitcountTrailingZero : (x : Int8) -> Int8``

Returns the count of trailing zero bits in `x`.

``func addWrap(x : Int8, y : Int8) : Int8``

Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow.

## subWrap

``func subWrap(x : Int8, y : Int8) : Int8``

Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow.

## mulWrap

``func mulWrap(x : Int8, y : Int8) : Int8``

Returns the product of `x` and `y`, `x *% y`. Wraps on overflow.

## powWrap

``func powWrap(x : Int8, y : Int8) : Int8``

Returns `x` to the power of `y`, `x **% y`. Wraps on overflow. Traps if `y < 0`.