package setr

You can search for identifiers within the package.

in-package search v0.2.0

package setr

setr
- SETr
- SETr_DS
- SETr_DS_CNF
  - ISet
  - Int
  - LSet
- SETr_DS_Dequeue
- SETr_DS_HMap
- SETr_DS_HSet
- SETr_DS_HashCons
  - HashedType
  - Make
    
    H
  - S
- SETr_DS_PSet
  - Compare
  - Make
    
    Ord
  - S
    
    Ord
- SETr_DS_SetOfSets
  - Comparable
  - Make
    
    C
    
    EMap
    
    ESet
  - S
    
    EMap
    
    ESet
- SETr_DomainBuilder
- SETr_Interface
- SETr_Lexer
- SETr_Parser
- SETr_Rename
- SETr_Select
- SETr_SymSing
- SETr_SymSing_Interface
  - S
- SETr_SymSing_Lin
- SETr_SymSing_Logic
- SETr_SymSing_Sing
  - Make
    
    D
- SETr_Symbolic
- SETr_Symbolic_BDD
  - Opt
- SETr_Symbolic_BDD_MLBDD
- SETr_Symbolic_BDD_XBDD
- SETr_Symbolic_BDD_XImp
  - Make
    
    HashedIf
    
    IfHashCons
    
    Var
  - VAR
- SETr_Symbolic_Debugger
  - Make
    
    D
- SETr_Symbolic_Equality
  - Make
    
    D
- SETr_Symbolic_Interface
  - S
- SETr_Symbolic_Logger
  - L
  - Make
    
    D
    
    L
- SETr_Symbolic_Logic
- SETr_Symbolic_Packer
  - Make
    
    D
- SETr_Symbolic_Remap
  - Inner
  - Make
    
    D
- SETr_Symbolic_Stats
  - Make
    
    D
- SETr_Symbolic_Tracer
  - L
  - Make
    
    D
    
    L

Legend:
Library
Module
Module type
Parameter
Class
Class type

type !'a set =

| Empty
| Node of 'a set * 'a * 'a set * int

type !'a t = 'a set

val empty : 'a t

val is_empty : 'a t -> bool

val mem : 'a -> 'a t -> bool

val add : 'a -> 'a t -> 'a t

val singleton : 'a -> 'a t

val remove : 'a -> 'a t -> 'a t

val union : 'a t -> 'a t -> 'a t

val inter : 'a t -> 'a t -> 'a t

val diff : 'a t -> 'a t -> 'a t

val compare : 'a t -> 'a t -> int

val equal : 'a t -> 'a t -> bool

val subset : 'a t -> 'a t -> bool

val iter : ('a -> unit) -> 'a t -> unit

val fold : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b

val for_all : ('a -> bool) -> 'a t -> bool

val exists : ('a -> bool) -> 'a t -> bool

val filter : ('a -> bool) -> 'a t -> 'a t

val partition : ('a -> bool) -> 'a t -> 'a t * 'a t

val cardinal : 'a t -> int

val elements : 'a t -> 'a list

val min_elt : 'a t -> 'a

val max_elt : 'a t -> 'a

val choose : 'a t -> 'a

val print : 
  ?first:(unit, Format.formatter, unit) format ->
  ?sep:(unit, Format.formatter, unit) format ->
  ?last:(unit, Format.formatter, unit) format ->
  (Format.formatter -> 'a -> unit) ->
  Format.formatter ->
  'a t ->
  unit

module type S = sig ... end

module Make (Ord : Set.OrderedType) : sig ... end

module Compare : sig ... end