kind stringclasses 5
values | name stringlengths 1 106 ⌀ | signature stringlengths 5 19.8k | documentation stringlengths 0 21.3k ⌀ | package_name stringclasses 1
value | package_version stringclasses 1
value | module_name stringlengths 1 134 | full_path stringlengths 1 155 |
|---|---|---|---|---|---|---|---|
value | compare | val compare : t -> t -> int | null | earley-ocaml | unknown | Mc2_core.Plugin.Factory | Mc2_core.Plugin.Factory.compare |
value | make | val make : ?priority:int -> name:string -> requires:'a service_key_list -> build:(int -> 'a service_list -> plugin) -> unit -> t | null | earley-ocaml | unknown | Mc2_core.Plugin.Factory | Mc2_core.Plugin.Factory.make |
type | null | type t | Lazy type for proof trees. Proofs are persistent objects, and can be extended to proof nodes using functions defined later. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof |
type | null | and node = { | A proof can be expanded into a proof node, which show the first step of the proof. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof |
type | null | and step = | A proof can be expanded into a proof node, which show the first step of the proof.The type of reasoning steps allowed in a proof. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof |
value | conclusion | val conclusion : node -> Mc2_core__.Solver_types.clause | null | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.conclusion |
value | step | val step : node -> step | null | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.step |
value | prove | val prove : Mc2_core__.Solver_types.clause -> t | Given a clause, return a proof of that clause.raises Util.Error if it does not succeed. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.prove |
value | prove_unsat | val prove_unsat : Mc2_core__.Solver_types.clause -> t | Given a conflict clause c, returns a proof of the empty clause.raises Util.Error if it does not succeed | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.prove_unsat |
value | prove_atom | val prove_atom : Mc2_core__.Solver_types.atom -> t option | Given an atom a, returns a proof of the clause [a] if a is true at level 0 | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.prove_atom |
value | is_leaf | val is_leaf : step -> bool | Returns whether the proof node is a leaf, i.e. an hypothesis, an assumption, or a lemma. true if and only if parents returns the empty list. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.is_leaf |
value | expl | val expl : step -> string | Returns a short string description for the proof step; for instance "hypothesis" for a Hypothesis (it currently returns the variant name in lowercase). | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.expl |
value | parents | val parents : step -> t list | Returns the parents of a proof node. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.parents |
value | expand | val expand : t -> node | Return the proof step at the root of a given proof. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.expand |
value | fold | val fold : ('a -> node -> 'a) -> 'a -> t -> 'a | fold f acc p, fold f over the proof p and all its node. It is guaranteed that f is executed exactly once on each proof node in the tree, and that the execution of f on a proof node happens after the execution on the parents of the nodes. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.fold |
value | iter | val iter : (node -> unit) -> t -> unit | null | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.iter |
value | unsat_core | val unsat_core : t -> Mc2_core__.Solver_types.clause list | Returns the unsat_core of the given proof, i.e the lists of conclusions of all leafs of the proof. More efficient than using the fold function since it has access to the internal representation of proofs | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.unsat_core |
value | debug_step | val debug_step : step CCFormat.printer | null | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.debug_step |
value | check_step | val check_step : t -> unit | Check only this proof step | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.check_step |
value | check | val check : t -> unit | Check the contents of a proof. Mainly for internal use | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof.check |
module | null | module H : CCHashtbl.S with type key = Mc2_core__.Solver_types.clause | Hashtable over clauses. Uses the details of the internal representation to achieve the best performances, however hashtables from this module become invalid when solving is restarted, so they should only be live during inspection of a single proof. | earley-ocaml | unknown | Mc2_core.Proof | Mc2_core.Proof |
type | null | type key | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H |
type | null | type !'a t | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H |
value | create | val create : int -> 'a t | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.create |
value | clear | val clear : 'a t -> unit | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.clear |
value | reset | val reset : 'a t -> unit | since 4.00 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.reset |
value | copy | val copy : 'a t -> 'a t | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.copy |
value | add | val add : 'a t -> key -> 'a -> unit | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add |
value | remove | val remove : 'a t -> key -> unit | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.remove |
value | find | val find : 'a t -> key -> 'a | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.find |
value | find_opt | val find_opt : 'a t -> key -> 'a option | since 4.05 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.find_opt |
value | find_all | val find_all : 'a t -> key -> 'a list | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.find_all |
value | replace | val replace : 'a t -> key -> 'a -> unit | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.replace |
value | mem | val mem : 'a t -> key -> bool | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.mem |
value | iter | val iter : (key -> 'a -> unit) -> 'a t -> unit | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.iter |
value | filter_map_inplace | val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit | since 4.03 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.filter_map_inplace |
value | fold | val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.fold |
value | length | val length : 'a t -> int | null | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.length |
value | stats | val stats : 'a t -> Hashtbl.statistics | since 4.00 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.stats |
value | to_seq | val to_seq : 'a t -> (key * 'a) Seq.t | since 4.07 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.to_seq |
value | to_seq_keys | val to_seq_keys : _ t -> key Seq.t | since 4.07 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.to_seq_keys |
value | to_seq_values | val to_seq_values : 'a t -> 'a Seq.t | since 4.07 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.to_seq_values |
value | replace_seq | val replace_seq : 'a t -> (key * 'a) Seq.t -> unit | since 4.07 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.replace_seq |
value | get | val get : 'a t -> key -> 'a option | get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find. | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.get |
value | get_or | val get_or : 'a t -> key -> default:'a -> 'a | get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).since 0.16 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.get_or |
value | add_list | val add_list : 'a list t -> key -> 'a -> unit | add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.since 0.16 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add_list |
value | incr | val incr : ?by:int -> int t -> key -> unit | incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).parameter by if specified, the int value is incremented by by rather than 1.since 0.16 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.incr |
value | decr | val decr : ?by:int -> int t -> key -> unit | decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.since 0.16 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.decr |
value | keys | val keys : 'a t -> key CCHashtbl.iter | keys tbl f iterates on keys (similar order as Hashtbl.iter). | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.keys |
value | values | val values : 'a t -> 'a CCHashtbl.iter | values tbl f iterates on values in the table. | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.values |
value | keys_list | val keys_list : _ t -> key list | keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.since 0.8 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.keys_list |
value | values_list | val values_list : 'a t -> 'a list | values_list t is the list of values in t.since 0.8 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.values_list |
value | map_list | val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list | Map on a hashtable's items, collect into a list. | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.map_list |
value | to_iter | val to_iter : 'a t -> (key * 'a) CCHashtbl.iter | Iterate on bindings in the table.since 2.8 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.to_iter |
value | add_iter | val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit | Add the corresponding pairs to the table, using Hashtbl.add.since 2.8 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add_iter |
value | add_iter_with | val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit | Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.since 3.3 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add_iter_with |
value | add_seq | val add_seq : 'a t -> (key * 'a) Seq.t -> unit | Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.since 3.0 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add_seq |
value | add_seq_with | val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Seq.t -> unit | Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.since 3.3 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add_seq_with |
value | of_iter | val of_iter : (key * 'a) CCHashtbl.iter -> 'a t | From the given bindings, added in order.since 2.8 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_iter |
value | of_iter_with | val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t | From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.since 3.3 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_iter_with |
value | of_seq | val of_seq : (key * 'a) Seq.t -> 'a t | From the given bindings, added in order. Renamed from of_std_seq since 3.0.since 3.0 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_seq |
value | of_seq_with | val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Seq.t -> 'a t | From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.since 3.3 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_seq_with |
value | add_iter_count | val add_iter_count : int t -> key CCHashtbl.iter -> unit | add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.since 2.8 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add_iter_count |
value | add_seq_count | val add_seq_count : int t -> key Seq.t -> unit | add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.since 3.0 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.add_seq_count |
value | of_iter_count | val of_iter_count : key CCHashtbl.iter -> int t | Like add_seq_count, but allocates a new table and returns it.since 2.8 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_iter_count |
value | of_seq_count | val of_seq_count : key Seq.t -> int t | Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.since 3.0 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_seq_count |
value | to_list | val to_list : 'a t -> (key * 'a) list | to_list tbl returns the list of (key,value) bindings (order unspecified). | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.to_list |
value | of_list | val of_list : (key * 'a) list -> 'a t | of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one. | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_list |
value | of_list_with | val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t | of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.since 3.3 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.of_list_with |
value | update | val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit | update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.since 0.14 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.update |
value | get_or_add | val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a | get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.since 1.0 | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.get_or_add |
value | pp | val pp : ?pp_start:unit CCHashtbl.printer -> ?pp_stop:unit CCHashtbl.printer -> ?pp_sep:unit CCHashtbl.printer -> ?pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer | pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow b... | earley-ocaml | unknown | Mc2_core.Proof.H | Mc2_core.Proof.H.pp |
module | null | module Key : sig ... end | The way to access a service registered by some plugin | earley-ocaml | unknown | Mc2_core.Service | Mc2_core.Service |
type | null | type any = | null | earley-ocaml | unknown | Mc2_core.Service | Mc2_core.Service |
module | null | module Registry : sig ... end | null | earley-ocaml | unknown | Mc2_core.Service | Mc2_core.Service |
type | null | type t | null | earley-ocaml | unknown | Mc2_core.Service.Registry | Mc2_core.Service.Registry |
value | create | val create : unit -> t | Create a registry | earley-ocaml | unknown | Mc2_core.Service.Registry | Mc2_core.Service.Registry.create |
value | register | val register : t -> 'a Key.t -> 'a -> unit | Register a service | earley-ocaml | unknown | Mc2_core.Service.Registry | Mc2_core.Service.Registry.register |
value | find | val find : t -> 'a Key.t -> 'a option | Find a service by its key | earley-ocaml | unknown | Mc2_core.Service.Registry | Mc2_core.Service.Registry.find |
value | find_exn | val find_exn : t -> 'a Key.t -> 'a | Find a service by its keyraises Util.Error if the key is not found | earley-ocaml | unknown | Mc2_core.Service.Registry | Mc2_core.Service.Registry.find_exn |
value | to_iter | val to_iter : t -> any Iter.t | all registered services | earley-ocaml | unknown | Mc2_core.Service.Registry | Mc2_core.Service.Registry.to_iter |
type | null | type 'a t | Key for values of type 'a lazy_t | earley-ocaml | unknown | Mc2_core.Service.Key | Mc2_core.Service.Key |
value | make | val make : string -> 'a t | Make a key with given name | earley-ocaml | unknown | Mc2_core.Service.Key | Mc2_core.Service.Key.make |
value | makef | val makef : ('a, Format.formatter, unit, 'b t) format4 -> 'a | Make a key with given nameFmt version of make | earley-ocaml | unknown | Mc2_core.Service.Key | Mc2_core.Service.Key.makef |
value | name | val name : _ t -> string | Fmt version of makeName of the key | earley-ocaml | unknown | Mc2_core.Service.Key | Mc2_core.Service.Key.name |
type | null | type key = int | The type of the map keys. | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map |
type | null | type !+'a t | The type of maps from type key to type 'a. | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map |
value | empty | val empty : 'a t | The empty map. | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.empty |
value | add | val add : key -> 'a -> 'a t -> 'a t | add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.before 4.03... | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.add |
value | add_to_list | val add_to_list : key -> 'a -> 'a list t -> 'a list t | add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.since 5.1 | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.add_to_list |
value | singleton | val singleton : key -> 'a -> 'a t | singleton x y returns the one-element map that contains a binding y for x.since 3.12 | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.singleton |
value | remove | val remove : key -> 'a t -> 'a t | remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).before 4.03 Physical equality was not ensured. | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.remove |
value | merge | val merge : (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t | merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f... | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.merge |
value | union | val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t | union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, wheref' _key None None = Nonef' _key (Some v) None = Some vf' _key... | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.union |
value | cardinal | val cardinal : 'a t -> int | Return the number of bindings of a map.since 3.12 | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.cardinal |
value | bindings | val bindings : 'a t -> (key * 'a) list | Return the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.since 3.12 | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.bindings |
value | min_binding | val min_binding : 'a t -> key * 'a | Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.since 3.12 | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.min_binding |
value | max_binding | val max_binding : 'a t -> key * 'a | Same as min_binding, but returns the binding with the largest key in the given map.since 3.12 | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.max_binding |
value | choose | val choose : 'a t -> key * 'a | Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.since 3.12 | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.choose |
value | find | val find : key -> 'a t -> 'a | find x m returns the current value of x in m, or raises Not_found if no binding for x exists. | earley-ocaml | unknown | Mc2_core.Int_map | Mc2_core.Int_map.find |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.