package bap-core-theory

You can search for identifiers within the package.

in-package search v0.2.0

bap-core-theory
- Bap_core_theory
  - Theory
    
    Basic
    
    Empty
    
    Make
    
    S
    
    Bitv
    
    Bool
    
    Core
    
    Documentation
    
    Theory
    
    Effect
    
    Sort
    
    Empty
    
    Fbasic
    
    Float
    
    Format
    
    IEEE754
    
    Sort
    
    Init
    
    Label
    
    Mem
    
    Memory
    
    Minimal
    
    Parser
    
    Grammar
    
    Bitv
    
    Bool
    
    Float
    
    Mem
    
    Rmode
    
    Stmt
    
    Make
    
    S
    
    Program
    
    Semantics
    
    Rmode
    
    Trans
    
    Value
    
    Sort
    
    Name
    
    Top
    
    Var
    
    Ident
    
    Top

Legend:
Library
Module
Module type
Parameter
Class
Class type

The name registry.

Names of symbols must be unique as the name is used as a witness of authenticity of the sort. Once obtained, the name should be kept secret beyond the module signature.

See the Example section of the Sort module documentation for more information.

type t

val declare : ?package:string -> string -> name

declare ?package name declares a new name.

The declared name must be unique to the package. If such name is already declared in the package, then the declaration fails.

include Base.Comparable.S with type t := t

include Base.Comparisons.S with type t := t

include Base.Comparisons.Infix with type t := t

val (>=) : t -> t -> bool

val (<=) : t -> t -> bool

val (=) : t -> t -> bool

val (>) : t -> t -> bool

val (<) : t -> t -> bool

val (<>) : t -> t -> bool

val equal : t -> t -> bool

val compare : t -> t -> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t

val max : t -> t -> t

val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int

val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t

include Base.Comparator.S with type t := t

type comparator_witness

val comparator : (t, comparator_witness) Base.Comparator.comparator

val validate_lbound : min:t Base.Maybe_bound.t -> t Base.Validate.check

val validate_ubound : max:t Base.Maybe_bound.t -> t Base.Validate.check

val validate_bound : 
  min:t Base.Maybe_bound.t ->
  max:t Base.Maybe_bound.t ->
  t Base.Validate.check