cryptol/docs/CryptolPrims.md

Comparisons and Ordering

(==)   :  {a}   (Cmp a) => a -> a -> Bit
(!=)   :  {a}   (Cmp a) => a -> a -> Bit
(===)  :  {a,b} (Cmp b) => (a -> b) -> (a -> b) -> a -> Bit
(!==)  :  {a,b} (Cmp b) => (a -> b) -> (a -> b) -> a -> Bit

(<)    :  {a} (Cmp a) => a -> a -> Bit
(>)    :  {a} (Cmp a) => a -> a -> Bit
(<=)   :  {a} (Cmp a) => a -> a -> Bit
(>=)   :  {a} (Cmp a) => a -> a -> Bit

min    :  {a} (Cmp a) => a -> a -> a
max    :  {a} (Cmp a) => a -> a -> a

instance Cmp Bit
// No instance for functions.
instance (Cmp a, fin n) => Cmp [n]a
instance (Cmp a, Cmp b) => Cmp (a,b)
instance (Cmp a, Cmp b) => Cmp { x : a, y : b }

Signed Comparisons

(<$) : {a} (SignedCmp a) => a -> a -> Bit
(>$) : {a} (SignedCmp a) => a -> a -> Bit
(<=$) : {a} (SignedCmp a) => a -> a -> Bit
(>=$) : {a} (SignedCmp a) => a -> a -> Bit

// No instance for Bit
// No instance for functions.
instance (fin n, n >= 1)            => SignedCmp [n]
instance (SignedCmp a, fin n)       => SignedCmp [n]a
        // (for [n]a, where a is other than Bit)
instance (SignedCmp a, SignedCmp b) => SignedCmp (a,b)
instance (SignedCmp a, SignedCmp b) => SignedCmp { x : a, y : b }

Arithmetic

(+)    : {a} (Arith a) => a -> a -> a
(-)    : {a} (Arith a) => a -> a -> a
(*)    : {a} (Arith a) => a -> a -> a
(/)    : {a} (Arith a) => a -> a -> a
(%)    : {a} (Arith a) => a -> a -> a
(^^)   : {a} (Arith a) => a -> a -> a
(/$)   : {a} (Arith a) => a -> a -> a
(%$)   : {a} (Arith a) => a -> a -> a

// No instance for `Bit`.
instance (fin n)            => Arith ( [n] Bit)
instance (Arith a)          => Arith ( [n] a)
instance (Arith b)          => Arith (a -> b)
instance (Arith a, Arith b) => Arith (a,b)
instance (Arith a, Arith b) => Arith { x : a, y : b }

Note that because there is no instances for Arith Bit the top two instances do not actually overlap.

Boolean

False : Bit
True  : Bit

zero  : a
(&&)  : a -> a -> a
(||)  : a -> a -> a
(^)   : a -> a -> a
(~)   : a -> a

(==>) : Bit -> Bit -> Bit
(/\)  : Bit -> Bit -> Bit
(\/)  : Bit -> Bit -> Bit

Sequences

length    : {n,a,m} (m >= width n) => [n]a -> [m]

join      : {parts,ench,a} (fin each) => [parts][each]a -> [parts * each]a
split     : {parts,each,a} (fin each) => [parts * each]a -> [parts][each]a

(#)       : {front,back,a} (fin front) => [front]a -> [back]a -> [front + back]a
splitAt   : {front,back,a} (fin front) => [from + back] a -> ([front] a, [back] a)

reverse   : {n,a} (fin n) => [n]a -> [n]a
transpose : {n,m,a} [n][m]a -> [m][n]a

(@)        : {n,a,m}              [n]a -> [m]    -> a
(@@)       : {n,a,m,i}            [n]a -> [m][i] -> [m]a
(!)        : {n,a,m}   (fin n) => [n]a -> [m]    -> a
(!!)       : {n,a,m,i} (fin n) => [n]a -> [m][i] -> [m]a
update     : {n,a,m} (fin m) => [n]a -> [m] -> a -> [n]a
updateEnd  : {n,a,m} (fin n, fin m) => [n]a -> [m] -> a -> [n]a
updates    : {n,a,m,d} (fin m, fin d) => [n]a -> [d][m] -> [d]a -> [n]a
updatesEnd : {n,a,m,d} (fin n, fin m, fin d) => [n]a -> [d][m] -> [d]a -> [n]a

// Abbreviations
groupBy n = split`{each  = n}
tail n    = splitAt`{front = 1}.1
take n    = splitAt`{front = n}.0
drop n    = splitAt`{front = n}.1

/* Also, `length` is not really needed:
   length : {n,a,m} (m >= width n) => [n]a -> [m]
   length _ = `n
 */

Shift And Rotate

New types:

(<<)   : {n,a,m} (fin n) => [n]a -> [m] -> [n]a
(>>)   : {n,a,m} (fin n) => [n]a -> [m] -> [n]a
(<<<)  : {n,a,m} (fin n) => [n]a -> [m] -> [n]a
(>>>)  : {n,a,m} (fin n) => [n]a -> [m] -> [n]a

// Arithmetic shift only for bitvectors
(>>$)  : {n, k} (fin n, n >= 1, fin k) => [n] -> [k] -> [n]

Random Values

random    : {a} => [256] -> a

Debugging

 undefined   : {a} a
 error       : {n a} [n][8] -> a
 trace       : {n, a, b} (fin n) => [n][8] -> a -> b -> b
 traceVal    : {n, a} (fin n) => [n][8] -> a -> a