You can search for identifiers within the package.
in-package search v0.2.0
Derive S from the minimal implementation.
S
module T : Base
type t = T.t
include Base with type t := t
val zero : t
element neutral to the addition
val one : t
element neutral to the multiplication
val succ : t -> t
succ n successor of n
succ n
n
val pred : t -> t
pred n is a predecessor of n
pred n
val abs : t -> t
abs x absolute value of x
abs x
x
val neg : t -> t
neg x = -x
neg x
-x
val add : t -> t -> t
add x y is x + y
add x y
x + y
val sub : t -> t -> t
sub x y is x - y
sub x y
x - y
val mul : t -> t -> t
mul x y is x * y
mul x y
x * y
val div : t -> t -> t
div x y is x / y
div x y
x / y
val modulo : t -> t -> t
modulo x y is x mod y
modulo x y
x mod y
val lnot : t -> t
lnot x is a logical negation of x (1-complement)
lnot x
logand x y is a conjunction of x and y
logand x y
y
val logand : t -> t -> t
val logor : t -> t -> t
logor x y is a disjunction of x and y
logor x y
val logxor : t -> t -> t
logxor x y is exclusive or between x and y
logxor x y
val lshift : t -> t -> t
lshift x y shift x by y bits left
lshift x y
val rshift : t -> t -> t
rshift x y shift x by y bits to the right
rshift x y
val arshift : t -> t -> t
arshift x y shift x by y bits to the right and fill with the sign bit.
arshift x y
val (~-) : t -> t
~-x = neg x
val (+) : t -> t -> t
x + y = add x y
val (-) : t -> t -> t
x - y = sub x y
val (*) : t -> t -> t
x * y = mul x y
val (/) : t -> t -> t
x / y = div x y
val (mod) : t -> t -> t
x mod y = modulo x y
val (land) : t -> t -> t
x land y = logand x y
val (lor) : t -> t -> t
x lor y = logor x y
val (lxor) : t -> t -> t
lxor x y = logxor x y
val (lsl) : t -> t -> t
x lsl y = lshift x y
val (lsr) : t -> t -> t
x lsr y = rshift x y
x lsr y
val (asr) : t -> t -> t
x asr y = arshift x y