Byte

is the data type for single bytes. Literals of type Byte are suffixed with b.

*

external

(Fn [Byte, Byte] Byte)

+

external

(Fn [Byte, Byte] Byte)

-

external

(Fn [Byte, Byte] Byte)

/

external

(Fn [Byte, Byte] Byte)

<

external

(Fn [Byte, Byte] Bool)

=

external

(Fn [Byte, Byte] Bool)

>

external

(Fn [Byte, Byte] Bool)

add-ref

defn

(Fn [(Ref Byte a), (Ref Byte b)] Byte)

                        (add-ref x y)
                    

bit-and

external

(Fn [Byte, Byte] Byte)

bit-not

external

(Fn [Byte] Byte)

bit-or

external

(Fn [Byte, Byte] Byte)

bit-shift-left

external

(Fn [Byte, Byte] Byte)

bit-shift-right

external

(Fn [Byte, Byte] Byte)

bit-xor

external

(Fn [Byte, Byte] Byte)

blit

defn

(Fn [Byte] Byte)

                        (blit x)
                    

clamp

defn

(Fn [a, a, a] a)

                        (clamp min max val)
                    

copy

external

(Fn [(Ref Byte a)] Byte)

dec

external

(Fn [Byte] Byte)

even?

defn

(Fn [Byte] Bool)

                        (even? a)
                    

format

external

(Fn [(Ref String a), Byte] String)

from-int

external

(Fn [Int] Byte)

from-string

defn

(Fn [(Ref String a)] (Maybe Byte))

                        (from-string s)
                    

hash

defn

(Fn [(Ref Byte a)] Int)

                        (hash k)
                    

inc

external

(Fn [Byte] Byte)

mod

external

(Fn [Byte, Byte] Byte)

odd?

defn

(Fn [Byte] Bool)

                        (odd? a)
                    

pow

defn

(Fn [Byte, Byte] Byte)

                        (pow x y)
                    

Raise x to the power of y.

prn

defn

(Fn [Byte] String)

                        (prn x)
                    

random

defn

(Fn [] Byte)

                        (random)
                    

random-between

defn

(Fn [Byte, Byte] Byte)

                        (random-between lower upper)
                    

str

external

(Fn [Byte] String)

to-int

external

(Fn [Byte] Int)

zero

defn

(Fn [] Byte)

                        (zero)