OCaml package documentation
Browse by name, by tag, the standard library and the OCaml manual (online, latest version).
Generated for /home/runner/work/moonpool/moonpool/_opam/lib
EitherThis module defines the common Either interface that is provided for all OCaml versions. For documentation of these functions, refer to the standard library.
val left : 'a -> ('a, 'b) tval right : 'b -> ('a, 'b) tval is_left : ('a, 'b) t -> boolval is_right : ('a, 'b) t -> boolval find_left : ('a, 'b) t -> 'a optionval find_right : ('a, 'b) t -> 'b optionval fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'cval iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unitval for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> boolEither__Either__Either_intfBrowse by name, by tag, the standard library and the OCaml manual (online, latest version).
Generated for /home/runner/work/moonpool/moonpool/_opam/lib
Moonpool.AtomicAtomic values.
This is either a shim using ref, on pre-OCaml 5, or the standard Atomic module on OCaml 5.
include module type of struct include Stdlib.Atomic endtype !'a t = 'a Stdlib.Atomic.tAn atomic (mutable) reference to a value of type 'a.
val make : 'a -> 'a tCreate an atomic reference.
val get : 'a t -> 'aGet the current value of the atomic reference.
val set : 'a t -> 'a -> unitSet a new value for the atomic reference.
val exchange : 'a t -> 'a -> 'aSet a new value for the atomic reference, and return the current value.
val compare_and_set : 'a t -> 'a -> 'a -> boolcompare_and_set r seen v sets the new value of r to v only if its current value is physically equal to seen -- the comparison and the set occur atomically. Returns true if the comparison succeeded (so the set happened) and false otherwise.
val fetch_and_add : int t -> int -> intfetch_and_add r n atomically increments the value of r by n, and returns the current value (before the increment).
val incr : int t -> unitincr r atomically increments the value of r by 1.
val decr : int t -> unitdecr r atomically decrements the value of r by 1.
Moonpool.Blocking_queueA simple blocking queue.
This queue is quite basic and will not behave well under heavy contention. However, it can be sufficient for many practical use cases.
NOTE: this queue will typically block the caller thread in case the operation (push/pop) cannot proceed. Be wary of deadlocks when using the queue from a pool when you expect the other end to also be produced/consumed from the same pool.
See discussion on Fut.wait_block for more details on deadlocks and how to mitigate the risk of running into them.
More scalable queues can be found in Lockfree (https://github.com/ocaml-multicore/lockfree/)
Unbounded blocking queue.
This queue is thread-safe and will block when calling pop on it when it's empty.
val create : unit -> _ tCreate a new unbounded queue.
val size : _ t -> intNumber of items currently in the queue. Note that pop might still block if this returns a non-zero number, since another thread might have consumed the items in the mean time.
val push : 'a t -> 'a -> unitpush q x pushes x into q, and returns ().
In the current implementation, push q will never block for a long time, it will only block while waiting for a lock so it can push the element.
val pop : 'a t -> 'apop q pops the next element in q. It might block until an element comes.
Moonpool.ChanChannels.
Channels are pipelines of values where threads can push into one end, and pull from the other end.
Unlike Moonpool.Blocking_queue, channels are designed so that pushing never blocks, and pop'ing values returns a future.
type 'a or_error = 'a Fut.or_errorval create : unit -> 'a tCreate a channel.
val push : 'a t -> 'a -> unitpush chan x pushes x into chan. This does not block.
Pop an element. This returns a future that will be fulfilled when an element is available.
val try_pop : 'a t -> 'a optiontry_pop chan pops and return an element if one is available immediately. Otherwise it returns None.
val pop_block_exn : 'a t -> 'aLike pop, but blocks if an element is not available immediately. The precautions around blocking from inside a thread pool are the same as explained in Fut.wait_block.
val close : _ t -> unitClose the channel. Further push and pop calls will fail. This is idempotent.
Moonpool.Fork_joinFork-join primitives.
NOTE These are only available on OCaml 5.0 and above.
Infix._val pool : Runner.tFut.InfixMake infix combinators
Fut.Infix_localOperators that run on the same thread as the first future.
Moonpool.FutFutures.
A future of type 'a t represents the result of a computation that will yield a value of type 'a.
Typically, the computation is running on a thread pool Runner.t and will proceed on some worker. Once set, a future cannot change. It either succeeds (storing a Ok x with x: 'a), or fail (storing a Error (exn, bt) with an exception and the corresponding backtrace).
Combinators such as map and join_array can be used to produce futures from other futures (in a monadic way). Some combinators take a on argument to specify a runner on which the intermediate computation takes place; for example map ~on:pool ~f fut maps the value in fut using function f, applicatively; the call to f happens on the runner pool (once fut resolves successfully with a value).
type 'a or_error = ('a, exn * Stdlib.Printexc.raw_backtrace) resulton_result fut f registers f to be called in the future when fut is set ; or calls f immediately if fut is already set.
Fullfill the promise, setting the future at the same time.
Fullfill the promise, setting the future at the same time. Does nothing if the promise is already fulfilled.
val return : 'a -> 'a tAlready settled future, with a result
val fail : exn -> Stdlib.Printexc.raw_backtrace -> _ tAlready settled future, with a failure
val is_resolved : _ t -> boolis_resolved fut is true iff fut is resolved.
peek fut returns Some r if fut is currently resolved with r, and None if fut is not resolved yet.
get_or_fail fut obtains the result from fut if it's fulfilled (i.e. if peek fut returns Some res, get_or_fail fut returns res).
val get_or_fail_exn : 'a t -> 'aget_or_fail_exn fut obtains the result from fut if it's fulfilled, like get_or_fail. If the result is an Error _, the exception inside is re-raised.
val is_done : _ t -> boolIs the future resolved? This is the same as peek fut |> Option.is_some.
spaw ~on f runs f() on the given runner on, and return a future that will hold its result.
reify_error fut turns a failing future into a non-failing one that contain Error (exn, bt). A non-failing future returning x is turned into Ok x
map ?on ~f fut returns a new future fut2 that resolves with f x if fut resolved with x; and fails with e if fut fails with e or f x raises e.
bind ?on ~f fut returns a new future fut2 that resolves like the future f x if fut resolved with x; and fails with e if fut fails with e or f x raises e.
bind_reify_error ?on ~f fut returns a new future fut2 that resolves like the future f (Ok x) if fut resolved with x; and resolves like the future f (Error (exn, bt)) if fut fails with exn and backtrace bt.
join fut is fut >>= Fun.id. It joins the inner layer of the future.
both a b succeeds with x, y if a succeeds with x and b succeeds with y, or fails if any of them fails.
choose a b succeeds Left x or Right y if a succeeds with x or b succeeds with y, or fails if both of them fails. If they both succeed, it is not specified which result is used.
choose_same a b succeeds with the value of one of a or b if they succeed, or fails if both fail. If they both succeed, it is not specified which result is used.
Wait for all the futures in the array. Fails if any future fails.
Wait for all the futures in the list. Fails if any future fails.
wait_array arr waits for all futures in arr to resolve. It discards the individual results of futures in arr. It fails if any future fails.
wait_list l waits for all futures in l to resolve. It discards the individual results of futures in l. It fails if any future fails.
for_ ~on n f runs f 0, f 1, …, f (n-1) on the runner, and returns a future that resolves when all the tasks have resolved, or fails as soon as one task has failed.
for_array ~on arr f runs f 0 arr.(0), …, f (n-1) arr.(n-1) in the runner (where n = Array.length arr), and returns a future that resolves when all the tasks are done, or fails if any of them fails.
for_list ~on l f is like for_array ~on (Array.of_list l) f.
NOTE This is only available on OCaml 5.
wait_block fut blocks the current thread until fut is resolved, and returns its value.
NOTE: A word of warning: this will monopolize the calling thread until the future resolves. This can also easily cause deadlocks, if enough threads in a pool call wait_block on futures running on the same pool or a pool depending on it.
A good rule to avoid deadlocks is to run this from outside of any pool, or to have an acyclic order between pools where wait_block is only called from a pool on futures evaluated in a pool that comes lower in the hierarchy. If this rule is broken, it is possible for all threads in a pool to wait for futures that can only make progress on these same threads, hence the deadlock.
val wait_block_exn : 'a t -> 'aSame as wait_block but re-raises the exception if the future failed.
module type INFIX = sig ... endmodule Infix_local : INFIXOperators that run on the same thread as the first future.
Fut.INFIXMoonpool.LockMutex-protected resource.
val create : 'a -> 'a tCreate a new protected value.
val with_ : 'a t -> ('a -> 'b) -> 'bwith_ l f runs f x where x is the value protected with the lock l, in a critical section. If f x fails, with_lock l f fails too but the lock is released.
val update : 'a t -> ('a -> 'a) -> unitupdate l f replaces the content x of l with f x, while protected by the mutex.
val update_map : 'a t -> ('a -> 'a * 'b) -> 'bupdate_map l f computes x', y = f (get l), then puts x' in l and returns y, while protected by the mutex.
val get : 'a t -> 'aAtomically get the value in the lock. The value that is returned isn't protected!
Pool.For_runner_implementorsMoonpool.PoolThread pool.
A pool of threads. The pool contains a fixed number of threads that wait for work items to come, process these, and loop.
This implements Runner.t since 0.3.
If a pool is no longer needed, shutdown can be used to signal all threads in it to stop (after they finish their work), and wait for them to stop.
The threads are distributed across a fixed domain pool (whose size is determined by Domain.recommended_domain_count on OCaml 5, and simply the single runtime on OCaml 4).
include module type of Runnertype t = private {run_async : task -> unit;shutdown : wait:bool -> unit -> unit;size : unit -> int;num_tasks : unit -> int;}A runner.
If a runner is no longer needed, shutdown can be used to signal all worker threads in it to stop (after they finish their work), and wait for them to stop.
The threads are distributed across a fixed domain pool (whose size is determined by Domain.recommended_domain_count on OCaml 5, and simple the single runtime on OCaml 4).
val size : t -> intNumber of threads/workers.
val num_tasks : t -> intCurrent number of tasks. This is at best a snapshot, useful for metrics and debugging.
val shutdown : t -> unitShutdown the runner and wait for it to terminate. Idempotent.
val shutdown_without_waiting : t -> unitShutdown the pool, and do not wait for it to terminate. Idempotent.
run_async pool f schedules f for later execution on the runner in one of the threads. f() will run on one of the runner's worker threads/domains.
val run_wait_block : t -> (unit -> 'a) -> 'arun_wait_block pool f schedules f for later execution on the pool, like run_async. It then blocks the current thread until f() is done executing, and returns its result. If f() raises an exception, then run_wait_block pool f will raise it as well.
NOTE be careful with deadlocks (see notes in Fut.wait_block).
module For_runner_implementors : sig ... endA thread wrapper f takes the current thread, the current pool, and the worker function loop : unit -> unit which is the worker's main loop, and returns a new loop function. By default it just returns the same loop function but it can be used to install tracing, effect handlers, etc.
val add_global_thread_loop_wrapper : thread_loop_wrapper -> unitadd_global_thread_loop_wrapper f installs f to be installed in every new pool worker thread, for all existing pools, and all new pools created with create. These wrappers accumulate: they all apply, but their order is not specified.
type ('a, 'b) create_args =
+ ?on_init_thread:(dom_id:int -> t_id:int -> unit -> unit) ->
+ ?on_exit_thread:(dom_id:int -> t_id:int -> unit -> unit) ->
+ ?thread_wrappers:thread_loop_wrapper list ->
+ ?on_exn:(exn -> Stdlib.Printexc.raw_backtrace -> unit) ->
+ ?around_task:((t -> 'b) * (t -> 'b -> unit)) ->
+ ?min:int ->
+ ?per_domain:int ->
+ 'aval create : (unit -> t, _) create_argscreate () makes a new thread pool.
val with_ : (unit -> (t -> 'a) -> 'a, _) create_argsRunner.For_runner_implementorsMoonpool.RunnerAbstract runner.
This provides an abstraction for running tasks in the background.
type t = private {run_async : task -> unit;shutdown : wait:bool -> unit -> unit;size : unit -> int;num_tasks : unit -> int;}A runner.
If a runner is no longer needed, shutdown can be used to signal all worker threads in it to stop (after they finish their work), and wait for them to stop.
The threads are distributed across a fixed domain pool (whose size is determined by Domain.recommended_domain_count on OCaml 5, and simple the single runtime on OCaml 4).
val size : t -> intNumber of threads/workers.
val num_tasks : t -> intCurrent number of tasks. This is at best a snapshot, useful for metrics and debugging.
val shutdown : t -> unitShutdown the runner and wait for it to terminate. Idempotent.
val shutdown_without_waiting : t -> unitShutdown the pool, and do not wait for it to terminate. Idempotent.
run_async pool f schedules f for later execution on the runner in one of the threads. f() will run on one of the runner's worker threads/domains.
val run_wait_block : t -> (unit -> 'a) -> 'arun_wait_block pool f schedules f for later execution on the pool, like run_async. It then blocks the current thread until f() is done executing, and returns its result. If f() raises an exception, then run_wait_block pool f will raise it as well.
NOTE be careful with deadlocks (see notes in Fut.wait_block).
module For_runner_implementors : sig ... endMoonpool.Suspend_Suspensions.
This is only going to work on OCaml 5.x.
NOTE: this is not stable for now.
(Private) suspending tasks using Effects.
This module is an implementation detail of Moonpool and should not be used outside of it, except by experts to implement Runner.
type suspension = (unit, exn * Stdlib.Printexc.raw_backtrace) result -> unitA suspended computation
The handler that knows what to do with the suspended computation.
The handler is given two things:
run function that can be used to start tasks to perform some computation.This means that a fork-join primitive, for example, can use a single call to suspend to:
run to start all the tasks. Typically run is called multiple times, which is where the "fork" part comes from. Each call to run potentially runs in parallel with the other calls. The calls must coordinate so that, once they are all done, the suspended caller is resumed with the aggregated result of the computation.val with_suspend :
+ run:(with_handler:bool -> task -> unit) ->
+ (unit -> unit) ->
+ unitwith_suspend ~run f runs f() in an environment where suspend will work. If f() suspends with suspension handler h, this calls h ~run k where k is the suspension.
This will not do anything on OCaml 4.x.
MoonpoolMoonpool
A pool within a bigger pool (ie the ocean). Here, we're talking about pools of Thread.t which live within a fixed pool of Domain.t.
module Pool : sig ... endThread pool.
module Runner : sig ... endAbstract runner.
val start_thread_on_some_domain : ('a -> unit) -> 'a -> Thread.tSimilar to Thread.create, but it picks a background domain at random to run the thread. This ensures that we don't always pick the same domain to run all the various threads needed in an application (timers, event loops, etc.)
module Lock : sig ... endMutex-protected resource.
module Fut : sig ... endFutures.
module Chan : sig ... endChannels.
module Fork_join : sig ... endFork-join primitives.
module Blocking_queue : sig ... endA simple blocking queue.
module Atomic : sig ... endAtomic values.
module Suspend_ : sig ... endSuspensions.
Moonpool__Moonpool__Atomic_Moonpool__Bb_queueMoonpool__ChanMoonpool__Dla_Moonpool__Domain_Moonpool__Fork_joinMoonpool__FutMoonpool__LockMoonpool__PoolMoonpool__RunnerMoonpool__Suspend_+You are assuming that, if pool P1 has 5000 tasks, and pool P2 has 10 other tasks, then these 10 tasks will get to run faster than if we just added them at the end of pool P1. This sounds like a “fairness” assumption: separate pools will get comparable shares of domain compute ressources, or at least no pool will be delayed too much from running their first tasks. + +[…] + +- each pool uses a fixed number of threads, all running simultaneously; if there are more tasks sent to the pool, they are delayed and will only get one of the pool threads when previous tasks have finished +- separate pools run their separate threads simultaneously, so they compete for compute resources on their domain using OCaml’s systhreads scheduler – which does provide fairness in practice +- as a result, running in a new pool enables quicker completion than adding to an existing pool (as we will be scheduled right away instead of waiting for previous tasks in our pool to free some threads) +- the ratio of compute resources that each pool gets should be roughly proportional to its number of worker threads ++ +## OCaml versions + +This works for OCaml >= 4.08. +- On OCaml 4.xx, there are no domains, so this is just a library for regular thread pools + with not actual parallelism (except for threads that call C code that releases the runtime lock, that is). +- on OCaml 5.xx, there is a fixed pool of domains (using the recommended domain count). + These domains do not do much by themselves, but we schedule new threads on them, and group + threads from each domain into pools. + Each domain might thus have multiple threads that belong to distinct pools (and several threads from + the same pool, too — this is useful for threads blocking on IO). + + A useful analogy is that each domain is a bit like a CPU core, and `Thread.t` is a logical thread running on a core. + Multiple threads have to share a single core and do not run in parallel on it[^1]. + We can therefore build pools that spread their worker threads on multiple cores to enable parallelism within each pool. + +TODO: actually use https://github.com/haesbaert/ocaml-processor to pin domains to cores, +possibly optionally using `select` in dune. + +## License + +MIT license. + +## Install + +```sh, skip +$ opam install moonpool +``` + +[^1]: let's not talk about hyperthreading. diff --git a/dev/moonpool/index.html b/dev/moonpool/index.html new file mode 100644 index 00000000..6dd80904 --- /dev/null +++ b/dev/moonpool/index.html @@ -0,0 +1,2 @@ + +
Moonpool MoonpoolAfl_instrumentInstrumentation for afl-fuzz.
val instrument_function : Cmm.expression -> Debuginfo.t -> Cmm.expressionval instrument_initialiser :
+ Cmm.expression ->
+ (unit -> Debuginfo.t) ->
+ Cmm.expressionAlias_analysistype allocated_const = | Normal of Allocated_const.t| Array of Lambda.array_kind * Asttypes.mutable_flag * Variable.t list| Duplicate_array of Lambda.array_kind * Asttypes.mutable_flag * Variable.ttype constant_defining_value = | Allocated_const of allocated_const| Block of Tag.t * Variable.t list| Set_of_closures of Flambda.set_of_closures| Project_closure of Flambda.project_closure| Move_within_set_of_closures of Flambda.move_within_set_of_closures| Project_var of Flambda.project_var| Field of Variable.t * int| Symbol_field of Symbol.t * int| Const of Flambda.const| Symbol of Symbol.t| Variable of Variable.ttype initialize_symbol_field = Variable.t optionval run :
+ constant_defining_value Variable.Tbl.t ->
+ initialize_symbol_field list Symbol.Tbl.t ->
+ Flambda.constant_defining_value Symbol.Tbl.t ->
+ the_dead_constant:Symbol.t ->
+ allocation_point Variable.Map.tSimple alias analysis working over information about which symbols have been assigned to variables; and which constants have been assigned to symbols. The return value gives the assignment of the defining values of constants to variables. Also see comments for Lift_constants, whose input feeds this pass.
Variables found to be ill-typed accesses to other constants, for example arising from dead code, will be pointed at the_dead_constant.
val print_constant_defining_value :
+ Stdlib.Format.formatter ->
+ constant_defining_value ->
+ unitAllocated_constConstants that are always allocated (possibly statically). Blocks are not included here since they are always encoded using Prim (Pmakeblock, ...).
val print : Stdlib.Format.formatter -> t -> unitAnnotArchval command_line_options : (string * Stdlib.Arg.spec * string) listtype specific_operation = | Ilea of addressing_mode| Istore_int of nativeint * addressing_mode * bool| Ioffset_loc of int * addressing_mode| Ifloatarithmem of float_operation * addressing_mode| Ibswap of int| Isqrtf| Ifloatsqrtf of addressing_mode| Isextend32| Izextend32val identity_addressing : addressing_modeval offset_addressing : addressing_mode -> int -> addressing_modeval num_args_addressing : addressing_mode -> intval print_addressing :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ addressing_mode ->
+ Stdlib.Format.formatter ->
+ 'b array ->
+ unitval print_specific_operation :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ specific_operation ->
+ Stdlib.Format.formatter ->
+ 'b array ->
+ unitval operation_is_pure : specific_operation -> boolKey.Maptype key = tThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
S.Keyval of_string : string -> tThe textual representation of a key must not contain '=' or ','.
S.Valueval of_string : string -> tThe textual representation of a value must not contain ','.
Make.SArg_helper.MakeArg_helperDecipher command line arguments of the form <value> | <key>=<value>,...
(as used for example for the specification of inlining parameters varying by simplification round).
Warning: this module is unstable and part of compiler-libs.
AsmgenFrom Lambda to assembly code
type middle_end =
+ backend:(module Backend_intf.S) ->
+ prefixname:string ->
+ ppf_dump:Stdlib.Format.formatter ->
+ Lambda.program ->
+ Clambda.with_constantsThe type of converters from Lambda to Clambda.
val compile_implementation :
+ ?toplevel:(string -> bool) ->
+ backend:(module Backend_intf.S) ->
+ prefixname:string ->
+ middle_end:middle_end ->
+ ppf_dump:Stdlib.Format.formatter ->
+ Lambda.program ->
+ unitCompile an implementation from Lambda using the given middle end.
val compile_phrase : ppf_dump:Stdlib.Format.formatter -> Cmm.phrase -> unittype error = | Assembler_error of string| Mismatched_for_pack of string option| Asm_generation of string * Emitaux.errorexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitAsmlibrarianexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitAsmlinkval link : ppf_dump:Stdlib.Format.formatter -> string list -> string -> unitval check_consistency :
+ Misc.filepath ->
+ Cmx_format.unit_infos ->
+ Stdlib.Digest.t ->
+ unitval extract_crc_interfaces : unit -> Misc.crcsval extract_crc_implementations : unit -> Misc.crcstype error = | File_not_found of Misc.filepath| Not_an_object_file of Misc.filepath| Missing_implementations of (Misc.modname * string list) list| Inconsistent_interface of Misc.modname * Misc.filepath * Misc.filepath| Inconsistent_implementation of Misc.modname * Misc.filepath * Misc.filepath| Assembler_error of Misc.filepath| Linking_error of int| Multiple_definition of Misc.modname * Misc.filepath * Misc.filepath| Missing_cmx of Misc.filepath * Misc.modnameexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitAsmpackagerval package_files :
+ ppf_dump:Stdlib.Format.formatter ->
+ Env.t ->
+ string list ->
+ string ->
+ backend:(module Backend_intf.S) ->
+ unitexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitAst_helper.Attrval mk : ?loc:loc -> str -> Parsetree.payload -> Parsetree.attributeAst_helper.CfClass fields
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ Parsetree.class_field_desc ->
+ Parsetree.class_fieldval attr :
+ Parsetree.class_field ->
+ Parsetree.attribute ->
+ Parsetree.class_fieldval inherit_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.override_flag ->
+ Parsetree.class_expr ->
+ str option ->
+ Parsetree.class_fieldval val_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str ->
+ Asttypes.mutable_flag ->
+ Parsetree.class_field_kind ->
+ Parsetree.class_fieldval method_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str ->
+ Asttypes.private_flag ->
+ Parsetree.class_field_kind ->
+ Parsetree.class_fieldval constraint_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.core_type ->
+ Parsetree.core_type ->
+ Parsetree.class_fieldval initializer_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.class_fieldval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.class_fieldval attribute : ?loc:loc -> Parsetree.attribute -> Parsetree.class_fieldval text : Docstrings.text -> Parsetree.class_field listval virtual_ : Parsetree.core_type -> Parsetree.class_field_kindval concrete :
+ Asttypes.override_flag ->
+ Parsetree.expression ->
+ Parsetree.class_field_kindAst_helper.CiClasses
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?text:Docstrings.text ->
+ ?virt:Asttypes.virtual_flag ->
+ ?params:
+ (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list ->
+ str ->
+ 'a ->
+ 'a Parsetree.class_infosAst_helper.ClClass expressions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_expr_desc ->
+ Parsetree.class_exprval attr : Parsetree.class_expr -> Parsetree.attribute -> Parsetree.class_exprval constr :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ Parsetree.core_type list ->
+ Parsetree.class_exprval structure :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_structure ->
+ Parsetree.class_exprval fun_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.arg_label ->
+ Parsetree.expression option ->
+ Parsetree.pattern ->
+ Parsetree.class_expr ->
+ Parsetree.class_exprval apply :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_expr ->
+ (Asttypes.arg_label * Parsetree.expression) list ->
+ Parsetree.class_exprval let_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.rec_flag ->
+ Parsetree.value_binding list ->
+ Parsetree.class_expr ->
+ Parsetree.class_exprval constraint_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_expr ->
+ Parsetree.class_type ->
+ Parsetree.class_exprval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.class_exprval open_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.open_description ->
+ Parsetree.class_expr ->
+ Parsetree.class_exprAst_helper.Constval char : char -> Parsetree.constantval string :
+ ?quotation_delimiter:string ->
+ ?loc:Location.t ->
+ string ->
+ Parsetree.constantval integer : ?suffix:char -> string -> Parsetree.constantval int : ?suffix:char -> int -> Parsetree.constantval int32 : ?suffix:char -> int32 -> Parsetree.constantval int64 : ?suffix:char -> int64 -> Parsetree.constantval nativeint : ?suffix:char -> nativeint -> Parsetree.constantval float : ?suffix:char -> string -> Parsetree.constantAst_helper.CsigClass signatures
val mk :
+ Parsetree.core_type ->
+ Parsetree.class_type_field list ->
+ Parsetree.class_signatureAst_helper.CstrClass structures
val mk :
+ Parsetree.pattern ->
+ Parsetree.class_field list ->
+ Parsetree.class_structureAst_helper.CtfClass type fields
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ Parsetree.class_type_field_desc ->
+ Parsetree.class_type_fieldval attr :
+ Parsetree.class_type_field ->
+ Parsetree.attribute ->
+ Parsetree.class_type_fieldval inherit_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_type ->
+ Parsetree.class_type_fieldval val_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str ->
+ Asttypes.mutable_flag ->
+ Asttypes.virtual_flag ->
+ Parsetree.core_type ->
+ Parsetree.class_type_fieldval method_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str ->
+ Asttypes.private_flag ->
+ Asttypes.virtual_flag ->
+ Parsetree.core_type ->
+ Parsetree.class_type_fieldval constraint_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.core_type ->
+ Parsetree.core_type ->
+ Parsetree.class_type_fieldval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.class_type_fieldval attribute : ?loc:loc -> Parsetree.attribute -> Parsetree.class_type_fieldval text : Docstrings.text -> Parsetree.class_type_field listAst_helper.CtyClass type expressions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_type_desc ->
+ Parsetree.class_typeval attr : Parsetree.class_type -> Parsetree.attribute -> Parsetree.class_typeval constr :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ Parsetree.core_type list ->
+ Parsetree.class_typeval signature :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_signature ->
+ Parsetree.class_typeval arrow :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.arg_label ->
+ Parsetree.core_type ->
+ Parsetree.class_type ->
+ Parsetree.class_typeval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.class_typeval open_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.open_description ->
+ Parsetree.class_type ->
+ Parsetree.class_typeAst_helper.ExpExpressions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression_desc ->
+ Parsetree.expressionval attr : Parsetree.expression -> Parsetree.attribute -> Parsetree.expressionval ident : ?loc:loc -> ?attrs:attrs -> lid -> Parsetree.expressionval constant :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.constant ->
+ Parsetree.expressionval let_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.rec_flag ->
+ Parsetree.value_binding list ->
+ Parsetree.expression ->
+ Parsetree.expressionval fun_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.arg_label ->
+ Parsetree.expression option ->
+ Parsetree.pattern ->
+ Parsetree.expression ->
+ Parsetree.expressionval function_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.case list ->
+ Parsetree.expressionval apply :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ (Asttypes.arg_label * Parsetree.expression) list ->
+ Parsetree.expressionval match_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.case list ->
+ Parsetree.expressionval try_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.case list ->
+ Parsetree.expressionval tuple :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression list ->
+ Parsetree.expressionval construct :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ Parsetree.expression option ->
+ Parsetree.expressionval variant :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.label ->
+ Parsetree.expression option ->
+ Parsetree.expressionval record :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ (lid * Parsetree.expression) list ->
+ Parsetree.expression option ->
+ Parsetree.expressionval field :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ lid ->
+ Parsetree.expressionval setfield :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ lid ->
+ Parsetree.expression ->
+ Parsetree.expressionval array :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression list ->
+ Parsetree.expressionval ifthenelse :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.expression ->
+ Parsetree.expression option ->
+ Parsetree.expressionval sequence :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.expression ->
+ Parsetree.expressionval while_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.expression ->
+ Parsetree.expressionval for_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern ->
+ Parsetree.expression ->
+ Parsetree.expression ->
+ Asttypes.direction_flag ->
+ Parsetree.expression ->
+ Parsetree.expressionval coerce :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.core_type option ->
+ Parsetree.core_type ->
+ Parsetree.expressionval constraint_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.core_type ->
+ Parsetree.expressionval send :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ str ->
+ Parsetree.expressionval new_ : ?loc:loc -> ?attrs:attrs -> lid -> Parsetree.expressionval setinstvar :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str ->
+ Parsetree.expression ->
+ Parsetree.expressionval override :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ (str * Parsetree.expression) list ->
+ Parsetree.expressionval letmodule :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str_opt ->
+ Parsetree.module_expr ->
+ Parsetree.expression ->
+ Parsetree.expressionval letexception :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension_constructor ->
+ Parsetree.expression ->
+ Parsetree.expressionval assert_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.expressionval lazy_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.expressionval poly :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.core_type option ->
+ Parsetree.expressionval object_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.class_structure ->
+ Parsetree.expressionval newtype :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str ->
+ Parsetree.expression ->
+ Parsetree.expressionval pack :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.module_expr ->
+ Parsetree.expressionval open_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.open_declaration ->
+ Parsetree.expression ->
+ Parsetree.expressionval letop :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.binding_op ->
+ Parsetree.binding_op list ->
+ Parsetree.expression ->
+ Parsetree.expressionval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.expressionval unreachable : ?loc:loc -> ?attrs:attrs -> unit -> Parsetree.expressionval case :
+ Parsetree.pattern ->
+ ?guard:Parsetree.expression ->
+ Parsetree.expression ->
+ Parsetree.caseval binding_op :
+ str ->
+ Parsetree.pattern ->
+ Parsetree.expression ->
+ loc ->
+ Parsetree.binding_opAst_helper.InclIncludes
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ 'a ->
+ 'a Parsetree.include_infosAst_helper.MbModule bindings
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?text:Docstrings.text ->
+ str_opt ->
+ Parsetree.module_expr ->
+ Parsetree.module_bindingAst_helper.MdModule declarations
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?text:Docstrings.text ->
+ str_opt ->
+ Parsetree.module_type ->
+ Parsetree.module_declarationAst_helper.ModModule expressions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.module_expr_desc ->
+ Parsetree.module_exprval attr :
+ Parsetree.module_expr ->
+ Parsetree.attribute ->
+ Parsetree.module_exprval ident : ?loc:loc -> ?attrs:attrs -> lid -> Parsetree.module_exprval structure :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.structure ->
+ Parsetree.module_exprval functor_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.functor_parameter ->
+ Parsetree.module_expr ->
+ Parsetree.module_exprval apply :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.module_expr ->
+ Parsetree.module_expr ->
+ Parsetree.module_exprval constraint_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.module_expr ->
+ Parsetree.module_type ->
+ Parsetree.module_exprval unpack :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.expression ->
+ Parsetree.module_exprval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.module_exprAst_helper.MsModule substitutions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?text:Docstrings.text ->
+ str ->
+ lid ->
+ Parsetree.module_substitutionAst_helper.MtdModule type declarations
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?text:Docstrings.text ->
+ ?typ:Parsetree.module_type ->
+ str ->
+ Parsetree.module_type_declarationAst_helper.MtyModule type expressions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.module_type_desc ->
+ Parsetree.module_typeval attr :
+ Parsetree.module_type ->
+ Parsetree.attribute ->
+ Parsetree.module_typeval ident : ?loc:loc -> ?attrs:attrs -> lid -> Parsetree.module_typeval alias : ?loc:loc -> ?attrs:attrs -> lid -> Parsetree.module_typeval signature :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.signature ->
+ Parsetree.module_typeval functor_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.functor_parameter ->
+ Parsetree.module_type ->
+ Parsetree.module_typeval with_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.module_type ->
+ Parsetree.with_constraint list ->
+ Parsetree.module_typeval typeof_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.module_expr ->
+ Parsetree.module_typeval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.module_typeAst_helper.OfObject fields
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.object_field_desc ->
+ Parsetree.object_fieldval tag :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.label with_loc ->
+ Parsetree.core_type ->
+ Parsetree.object_fieldval inherit_ : ?loc:loc -> Parsetree.core_type -> Parsetree.object_fieldAst_helper.OpnOpens
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?override:Asttypes.override_flag ->
+ 'a ->
+ 'a Parsetree.open_infosAst_helper.PatPatterns
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern_desc ->
+ Parsetree.patternval attr : Parsetree.pattern -> Parsetree.attribute -> Parsetree.patternval any : ?loc:loc -> ?attrs:attrs -> unit -> Parsetree.patternval var : ?loc:loc -> ?attrs:attrs -> str -> Parsetree.patternval alias :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern ->
+ str ->
+ Parsetree.patternval constant :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.constant ->
+ Parsetree.patternval interval :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.constant ->
+ Parsetree.constant ->
+ Parsetree.patternval tuple :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern list ->
+ Parsetree.patternval construct :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ (str list * Parsetree.pattern) option ->
+ Parsetree.patternval variant :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.label ->
+ Parsetree.pattern option ->
+ Parsetree.patternval record :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ (lid * Parsetree.pattern) list ->
+ Asttypes.closed_flag ->
+ Parsetree.patternval array :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern list ->
+ Parsetree.patternval or_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern ->
+ Parsetree.pattern ->
+ Parsetree.patternval constraint_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern ->
+ Parsetree.core_type ->
+ Parsetree.patternval type_ : ?loc:loc -> ?attrs:attrs -> lid -> Parsetree.patternval lazy_ : ?loc:loc -> ?attrs:attrs -> Parsetree.pattern -> Parsetree.patternval unpack : ?loc:loc -> ?attrs:attrs -> str_opt -> Parsetree.patternval open_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ Parsetree.pattern ->
+ Parsetree.patternval exception_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.pattern ->
+ Parsetree.patternval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.patternAst_helper.RfRow fields
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.row_field_desc ->
+ Parsetree.row_fieldval tag :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.label with_loc ->
+ bool ->
+ Parsetree.core_type list ->
+ Parsetree.row_fieldval inherit_ : ?loc:loc -> Parsetree.core_type -> Parsetree.row_fieldAst_helper.SigSignature items
val mk : ?loc:loc -> Parsetree.signature_item_desc -> Parsetree.signature_itemval value : ?loc:loc -> Parsetree.value_description -> Parsetree.signature_itemval type_ :
+ ?loc:loc ->
+ Asttypes.rec_flag ->
+ Parsetree.type_declaration list ->
+ Parsetree.signature_itemval type_subst :
+ ?loc:loc ->
+ Parsetree.type_declaration list ->
+ Parsetree.signature_itemval type_extension :
+ ?loc:loc ->
+ Parsetree.type_extension ->
+ Parsetree.signature_itemval exception_ :
+ ?loc:loc ->
+ Parsetree.type_exception ->
+ Parsetree.signature_itemval module_ :
+ ?loc:loc ->
+ Parsetree.module_declaration ->
+ Parsetree.signature_itemval mod_subst :
+ ?loc:loc ->
+ Parsetree.module_substitution ->
+ Parsetree.signature_itemval rec_module :
+ ?loc:loc ->
+ Parsetree.module_declaration list ->
+ Parsetree.signature_itemval modtype :
+ ?loc:loc ->
+ Parsetree.module_type_declaration ->
+ Parsetree.signature_itemval modtype_subst :
+ ?loc:loc ->
+ Parsetree.module_type_declaration ->
+ Parsetree.signature_itemval open_ : ?loc:loc -> Parsetree.open_description -> Parsetree.signature_itemval include_ :
+ ?loc:loc ->
+ Parsetree.include_description ->
+ Parsetree.signature_itemval class_ :
+ ?loc:loc ->
+ Parsetree.class_description list ->
+ Parsetree.signature_itemval class_type :
+ ?loc:loc ->
+ Parsetree.class_type_declaration list ->
+ Parsetree.signature_itemval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.signature_itemval attribute : ?loc:loc -> Parsetree.attribute -> Parsetree.signature_itemval text : Docstrings.text -> Parsetree.signature_item listAst_helper.StrStructure items
val mk : ?loc:loc -> Parsetree.structure_item_desc -> Parsetree.structure_itemval eval :
+ ?loc:loc ->
+ ?attrs:Parsetree.attributes ->
+ Parsetree.expression ->
+ Parsetree.structure_itemval value :
+ ?loc:loc ->
+ Asttypes.rec_flag ->
+ Parsetree.value_binding list ->
+ Parsetree.structure_itemval primitive :
+ ?loc:loc ->
+ Parsetree.value_description ->
+ Parsetree.structure_itemval type_ :
+ ?loc:loc ->
+ Asttypes.rec_flag ->
+ Parsetree.type_declaration list ->
+ Parsetree.structure_itemval type_extension :
+ ?loc:loc ->
+ Parsetree.type_extension ->
+ Parsetree.structure_itemval exception_ :
+ ?loc:loc ->
+ Parsetree.type_exception ->
+ Parsetree.structure_itemval module_ : ?loc:loc -> Parsetree.module_binding -> Parsetree.structure_itemval rec_module :
+ ?loc:loc ->
+ Parsetree.module_binding list ->
+ Parsetree.structure_itemval modtype :
+ ?loc:loc ->
+ Parsetree.module_type_declaration ->
+ Parsetree.structure_itemval open_ : ?loc:loc -> Parsetree.open_declaration -> Parsetree.structure_itemval class_ :
+ ?loc:loc ->
+ Parsetree.class_declaration list ->
+ Parsetree.structure_itemval class_type :
+ ?loc:loc ->
+ Parsetree.class_type_declaration list ->
+ Parsetree.structure_itemval include_ :
+ ?loc:loc ->
+ Parsetree.include_declaration ->
+ Parsetree.structure_itemval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.structure_itemval attribute : ?loc:loc -> Parsetree.attribute -> Parsetree.structure_itemval text : Docstrings.text -> Parsetree.structure_item listAst_helper.TeType extensions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?params:
+ (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list ->
+ ?priv:Asttypes.private_flag ->
+ lid ->
+ Parsetree.extension_constructor list ->
+ Parsetree.type_extensionval mk_exception :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ Parsetree.extension_constructor ->
+ Parsetree.type_exceptionval constructor :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?info:Docstrings.info ->
+ str ->
+ Parsetree.extension_constructor_kind ->
+ Parsetree.extension_constructorval decl :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?info:Docstrings.info ->
+ ?vars:str list ->
+ ?args:Parsetree.constructor_arguments ->
+ ?res:Parsetree.core_type ->
+ str ->
+ Parsetree.extension_constructorval rebind :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?info:Docstrings.info ->
+ str ->
+ lid ->
+ Parsetree.extension_constructorAst_helper.TypType expressions
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.core_type_desc ->
+ Parsetree.core_typeval attr : Parsetree.core_type -> Parsetree.attribute -> Parsetree.core_typeval any : ?loc:loc -> ?attrs:attrs -> unit -> Parsetree.core_typeval var : ?loc:loc -> ?attrs:attrs -> string -> Parsetree.core_typeval arrow :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Asttypes.arg_label ->
+ Parsetree.core_type ->
+ Parsetree.core_type ->
+ Parsetree.core_typeval tuple :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.core_type list ->
+ Parsetree.core_typeval constr :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ Parsetree.core_type list ->
+ Parsetree.core_typeval object_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.object_field list ->
+ Asttypes.closed_flag ->
+ Parsetree.core_typeval class_ :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ Parsetree.core_type list ->
+ Parsetree.core_typeval alias :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.core_type ->
+ string ->
+ Parsetree.core_typeval variant :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.row_field list ->
+ Asttypes.closed_flag ->
+ Asttypes.label list option ->
+ Parsetree.core_typeval poly :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ str list ->
+ Parsetree.core_type ->
+ Parsetree.core_typeval package :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ lid ->
+ (lid * Parsetree.core_type) list ->
+ Parsetree.core_typeval extension :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ Parsetree.extension ->
+ Parsetree.core_typeval force_poly : Parsetree.core_type -> Parsetree.core_typeval varify_constructors :
+ str list ->
+ Parsetree.core_type ->
+ Parsetree.core_typevarify_constructors newtypes te is type expression te, of which any of nullary type constructor tc is replaced by type variable of the same name, if tc's name appears in newtypes. Raise Syntaxerr.Variable_in_scope if any type variable inside te appears in newtypes.
Ast_helper.TypeType declarations
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?text:Docstrings.text ->
+ ?params:
+ (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list ->
+ ?cstrs:(Parsetree.core_type * Parsetree.core_type * loc) list ->
+ ?kind:Parsetree.type_kind ->
+ ?priv:Asttypes.private_flag ->
+ ?manifest:Parsetree.core_type ->
+ str ->
+ Parsetree.type_declarationval constructor :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?info:Docstrings.info ->
+ ?vars:str list ->
+ ?args:Parsetree.constructor_arguments ->
+ ?res:Parsetree.core_type ->
+ str ->
+ Parsetree.constructor_declarationval field :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?info:Docstrings.info ->
+ ?mut:Asttypes.mutable_flag ->
+ str ->
+ Parsetree.core_type ->
+ Parsetree.label_declarationAst_helper.ValValue declarations
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?prim:string list ->
+ str ->
+ Parsetree.core_type ->
+ Parsetree.value_descriptionAst_helper.VbValue bindings
val mk :
+ ?loc:loc ->
+ ?attrs:attrs ->
+ ?docs:Docstrings.docs ->
+ ?text:Docstrings.text ->
+ Parsetree.pattern ->
+ Parsetree.expression ->
+ Parsetree.value_bindingAst_helperHelpers to produce Parsetree fragments
Warning This module is unstable and part of compiler-libs.
type 'a with_loc = 'a Location.loctype loc = Location.ttype lid = Longident.t with_loctype str = string with_loctype str_opt = string option with_loctype attrs = Parsetree.attribute listval with_default_loc : loc -> (unit -> 'a) -> 'aSet the default_loc within the scope of the execution of the provided function.
module Const : sig ... endmodule Attr : sig ... endmodule Typ : sig ... endType expressions
module Pat : sig ... endPatterns
module Exp : sig ... endExpressions
module Val : sig ... endValue declarations
module Type : sig ... endType declarations
module Te : sig ... endType extensions
module Mty : sig ... endModule type expressions
module Mod : sig ... endModule expressions
module Sig : sig ... endSignature items
module Str : sig ... endStructure items
module Md : sig ... endModule declarations
module Ms : sig ... endModule substitutions
module Mtd : sig ... endModule type declarations
module Mb : sig ... endModule bindings
module Opn : sig ... endOpens
module Incl : sig ... endIncludes
module Vb : sig ... endValue bindings
module Cty : sig ... endClass type expressions
module Ctf : sig ... endClass type fields
module Cl : sig ... endClass expressions
module Cf : sig ... endClass fields
module Ci : sig ... endClasses
module Csig : sig ... endClass signatures
module Cstr : sig ... endClass structures
module Rf : sig ... endRow fields
module Of : sig ... endObject fields
Ast_invariantsCheck AST invariants
Warning: this module is unstable and part of compiler-libs.
val structure : Parsetree.structure -> unitval signature : Parsetree.signature -> unitAst_iteratorAst_iterator.iterator enables AST inspection using open recursion. A typical mapper would be based on Ast_iterator.default_iterator, a trivial iterator, and will fall back on it for handling the syntax it does not modify.
Warning: this module is unstable and part of compiler-libs.
type iterator = {attribute : iterator -> Parsetree.attribute -> unit;attributes : iterator -> Parsetree.attribute list -> unit;binding_op : iterator -> Parsetree.binding_op -> unit;case : iterator -> Parsetree.case -> unit;cases : iterator -> Parsetree.case list -> unit;class_declaration : iterator -> Parsetree.class_declaration -> unit;class_description : iterator -> Parsetree.class_description -> unit;class_expr : iterator -> Parsetree.class_expr -> unit;class_field : iterator -> Parsetree.class_field -> unit;class_signature : iterator -> Parsetree.class_signature -> unit;class_structure : iterator -> Parsetree.class_structure -> unit;class_type : iterator -> Parsetree.class_type -> unit;class_type_declaration : iterator -> Parsetree.class_type_declaration -> unit;class_type_field : iterator -> Parsetree.class_type_field -> unit;constructor_declaration : iterator ->
+ Parsetree.constructor_declaration ->
+ unit;expr : iterator -> Parsetree.expression -> unit;extension : iterator -> Parsetree.extension -> unit;extension_constructor : iterator -> Parsetree.extension_constructor -> unit;include_declaration : iterator -> Parsetree.include_declaration -> unit;include_description : iterator -> Parsetree.include_description -> unit;label_declaration : iterator -> Parsetree.label_declaration -> unit;location : iterator -> Location.t -> unit;module_binding : iterator -> Parsetree.module_binding -> unit;module_declaration : iterator -> Parsetree.module_declaration -> unit;module_substitution : iterator -> Parsetree.module_substitution -> unit;module_expr : iterator -> Parsetree.module_expr -> unit;module_type : iterator -> Parsetree.module_type -> unit;module_type_declaration : iterator ->
+ Parsetree.module_type_declaration ->
+ unit;open_declaration : iterator -> Parsetree.open_declaration -> unit;open_description : iterator -> Parsetree.open_description -> unit;pat : iterator -> Parsetree.pattern -> unit;payload : iterator -> Parsetree.payload -> unit;signature : iterator -> Parsetree.signature -> unit;signature_item : iterator -> Parsetree.signature_item -> unit;structure : iterator -> Parsetree.structure -> unit;structure_item : iterator -> Parsetree.structure_item -> unit;typ : iterator -> Parsetree.core_type -> unit;row_field : iterator -> Parsetree.row_field -> unit;object_field : iterator -> Parsetree.object_field -> unit;type_declaration : iterator -> Parsetree.type_declaration -> unit;type_extension : iterator -> Parsetree.type_extension -> unit;type_exception : iterator -> Parsetree.type_exception -> unit;type_kind : iterator -> Parsetree.type_kind -> unit;value_binding : iterator -> Parsetree.value_binding -> unit;value_description : iterator -> Parsetree.value_description -> unit;with_constraint : iterator -> Parsetree.with_constraint -> unit;}A iterator record implements one "method" per syntactic category, using an open recursion style: each method takes as its first argument the iterator to be applied to children in the syntax tree.
val default_iterator : iteratorA default iterator, which implements a "do not do anything" mapping.
Ast_mapperThe interface of a -ppx rewriter
A -ppx rewriter is a program that accepts a serialized abstract syntax tree and outputs another, possibly modified, abstract syntax tree. This module encapsulates the interface between the compiler and the -ppx rewriters, handling such details as the serialization format, forwarding of command-line flags, and storing state.
mapper enables AST rewriting using open recursion. A typical mapper would be based on default_mapper, a deep identity mapper, and will fall back on it for handling the syntax it does not modify. For example:
open Asttypes
+open Parsetree
+open Ast_mapper
+
+let test_mapper argv =
+ { default_mapper with
+ expr = fun mapper expr ->
+ match expr with
+ | { pexp_desc = Pexp_extension ({ txt = "test" }, PStr [])} ->
+ Ast_helper.Exp.constant (Const_int 42)
+ | other -> default_mapper.expr mapper other; }
+
+let () =
+ register "ppx_test" test_mapperThis -ppx rewriter, which replaces [%test] in expressions with the constant 42, can be compiled using ocamlc -o ppx_test -I +compiler-libs ocamlcommon.cma ppx_test.ml.
Warning: this module is unstable and part of compiler-libs.
type mapper = {attribute : mapper -> Parsetree.attribute -> Parsetree.attribute;attributes : mapper -> Parsetree.attribute list -> Parsetree.attribute list;binding_op : mapper -> Parsetree.binding_op -> Parsetree.binding_op;case : mapper -> Parsetree.case -> Parsetree.case;cases : mapper -> Parsetree.case list -> Parsetree.case list;class_declaration : mapper ->
+ Parsetree.class_declaration ->
+ Parsetree.class_declaration;class_description : mapper ->
+ Parsetree.class_description ->
+ Parsetree.class_description;class_expr : mapper -> Parsetree.class_expr -> Parsetree.class_expr;class_field : mapper -> Parsetree.class_field -> Parsetree.class_field;class_signature : mapper ->
+ Parsetree.class_signature ->
+ Parsetree.class_signature;class_structure : mapper ->
+ Parsetree.class_structure ->
+ Parsetree.class_structure;class_type : mapper -> Parsetree.class_type -> Parsetree.class_type;class_type_declaration : mapper ->
+ Parsetree.class_type_declaration ->
+ Parsetree.class_type_declaration;class_type_field : mapper ->
+ Parsetree.class_type_field ->
+ Parsetree.class_type_field;constant : mapper -> Parsetree.constant -> Parsetree.constant;constructor_declaration : mapper ->
+ Parsetree.constructor_declaration ->
+ Parsetree.constructor_declaration;expr : mapper -> Parsetree.expression -> Parsetree.expression;extension : mapper -> Parsetree.extension -> Parsetree.extension;extension_constructor : mapper ->
+ Parsetree.extension_constructor ->
+ Parsetree.extension_constructor;include_declaration : mapper ->
+ Parsetree.include_declaration ->
+ Parsetree.include_declaration;include_description : mapper ->
+ Parsetree.include_description ->
+ Parsetree.include_description;label_declaration : mapper ->
+ Parsetree.label_declaration ->
+ Parsetree.label_declaration;location : mapper -> Location.t -> Location.t;module_binding : mapper ->
+ Parsetree.module_binding ->
+ Parsetree.module_binding;module_declaration : mapper ->
+ Parsetree.module_declaration ->
+ Parsetree.module_declaration;module_substitution : mapper ->
+ Parsetree.module_substitution ->
+ Parsetree.module_substitution;module_expr : mapper -> Parsetree.module_expr -> Parsetree.module_expr;module_type : mapper -> Parsetree.module_type -> Parsetree.module_type;module_type_declaration : mapper ->
+ Parsetree.module_type_declaration ->
+ Parsetree.module_type_declaration;open_declaration : mapper ->
+ Parsetree.open_declaration ->
+ Parsetree.open_declaration;open_description : mapper ->
+ Parsetree.open_description ->
+ Parsetree.open_description;pat : mapper -> Parsetree.pattern -> Parsetree.pattern;payload : mapper -> Parsetree.payload -> Parsetree.payload;signature : mapper -> Parsetree.signature -> Parsetree.signature;signature_item : mapper ->
+ Parsetree.signature_item ->
+ Parsetree.signature_item;structure : mapper -> Parsetree.structure -> Parsetree.structure;structure_item : mapper ->
+ Parsetree.structure_item ->
+ Parsetree.structure_item;typ : mapper -> Parsetree.core_type -> Parsetree.core_type;type_declaration : mapper ->
+ Parsetree.type_declaration ->
+ Parsetree.type_declaration;type_extension : mapper ->
+ Parsetree.type_extension ->
+ Parsetree.type_extension;type_exception : mapper ->
+ Parsetree.type_exception ->
+ Parsetree.type_exception;type_kind : mapper -> Parsetree.type_kind -> Parsetree.type_kind;value_binding : mapper -> Parsetree.value_binding -> Parsetree.value_binding;value_description : mapper ->
+ Parsetree.value_description ->
+ Parsetree.value_description;with_constraint : mapper ->
+ Parsetree.with_constraint ->
+ Parsetree.with_constraint;}A mapper record implements one "method" per syntactic category, using an open recursion style: each method takes as its first argument the mapper to be applied to children in the syntax tree.
val default_mapper : mapperA default mapper, which implements a "deep identity" mapping.
Can be used within a ppx preprocessor to know which tool is calling it "ocamlc", "ocamlopt", "ocamldoc", "ocamldep", "ocaml", ... Some global variables that reflect command-line options are automatically synchronized between the calling tool and the ppx preprocessor: Clflags.include_dirs, Load_path, Clflags.open_modules, Clflags.for_package, Clflags.debug.
val apply : source:string -> target:string -> mapper -> unitApply a mapper (parametrized by the unit name) to a dumped parsetree found in the source file and put the result in the target file. The structure or signature field of the mapper is applied to the implementation or interface.
val run_main : (string list -> mapper) -> unitEntry point to call to implement a standalone -ppx rewriter from a mapper, parametrized by the command line arguments. The current unit name can be obtained from Location.input_name. This function implements proper error reporting for uncaught exceptions.
val register : string -> (string list -> mapper) -> unitApply the register_function. The default behavior is to run the mapper immediately, taking arguments from the process command line. This is to support a scenario where a mapper is linked as a stand-alone executable.
It is possible to overwrite the register_function to define "-ppx drivers", which combine several mappers in a single process. Typically, a driver starts by defining register_function to a custom implementation, then lets ppx rewriters (linked statically or dynamically) register themselves, and then run all or some of them. It is also possible to have -ppx drivers apply rewriters to only specific parts of an AST.
The first argument to register is a symbolic name to be used by the ppx driver.
val extension_of_error : Location.error -> Parsetree.extensionEncode an error into an 'ocaml.error' extension node which can be inserted in a generated Parsetree. The compiler will be responsible for reporting the error.
val attribute_of_warning : Location.t -> string -> Parsetree.attributeEncode a warning message into an 'ocaml.ppwarning' attribute which can be inserted in a generated Parsetree. The compiler will be responsible for reporting the warning.
val add_ppx_context_str :
+ tool_name:string ->
+ Parsetree.structure ->
+ Parsetree.structureExtract information from the current environment and encode it into an attribute which is prepended to the list of structure items in order to pass the information to an external processor.
val add_ppx_context_sig :
+ tool_name:string ->
+ Parsetree.signature ->
+ Parsetree.signatureSame as add_ppx_context_str, but for signatures.
val drop_ppx_context_str :
+ restore:bool ->
+ Parsetree.structure ->
+ Parsetree.structureDrop the ocaml.ppx.context attribute from a structure. If restore is true, also restore the associated data in the current process.
val drop_ppx_context_sig :
+ restore:bool ->
+ Parsetree.signature ->
+ Parsetree.signatureSame as drop_ppx_context_str, but for signatures.
Cookies are used to pass information from a ppx processor to a further invocation of itself, when called from the OCaml toplevel (or other tools that support cookies).
val set_cookie : string -> Parsetree.expression -> unitval get_cookie : string -> Parsetree.expression optionAsttypesAuxiliary AST types used by parsetree and typedtree.
Warning: this module is unstable and part of compiler-libs.
type constant = | Const_int of int| Const_char of char| Const_string of string * Location.t * string option| Const_float of string| Const_int32 of int32| Const_int64 of int64| Const_nativeint of nativeintAttr_helperHelpers for attributes
Warning: this module is unstable and part of compiler-libs.
val get_no_payload_attribute :
+ string list ->
+ Parsetree.attributes ->
+ string Asttypes.loc optionThe string list argument of the following functions is a list of alternative names for the attribute we are looking for. For instance:
["foo"; "ocaml.foo"]val has_no_payload_attribute : string list -> Parsetree.attributes -> boolexception Error of Location.t * errorval report_error : Stdlib.Format.formatter -> error -> unitAugment_specialised_args.Definitiontype t = | Existing_inner_free_var of Variable.t| Projection_from_existing_specialised_arg of Projection.tMake._val what_to_specialise :
+ env:Inline_and_simplify_aux.Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ What_to_specialise.tAugment_specialised_args.Makeval rewrite_set_of_closures :
+ env:Inline_and_simplify_aux.Env.t ->
+ duplicate_function:
+ (env:Inline_and_simplify_aux.Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ fun_var:Variable.t ->
+ new_fun_var:Variable.t ->
+ Flambda.function_declaration * Flambda.specialised_to Variable.Map.t) ->
+ set_of_closures:Flambda.set_of_closures ->
+ (Flambda.expr * Inlining_cost.Benefit.t) optionduplicate_function should be Inline_and_simplify.duplicate_function.
Augment_specialised_args.What_to_specialiseval create : set_of_closures:Flambda.set_of_closures -> tval new_specialised_arg :
+ t ->
+ fun_var:Variable.t ->
+ group:Variable.t ->
+ definition:Definition.t ->
+ tval make_direct_call_surrogate_for : t -> fun_var:Variable.t -> tAugment_specialised_argsHelper module for adding specialised arguments to sets of closures.
Augment_specialised_args.Sval what_to_specialise :
+ env:Inline_and_simplify_aux.Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ What_to_specialise.tBackend_intfKnowledge that the middle end needs about the backend.
module type S = sig ... endBackend_intf.Sval really_import_approx : Simple_value_approx.t -> Simple_value_approx.tIf the given approximation is that of a symbol (Value_symbol) or an external (Value_extern), attempt to find a more informative approximation from a previously-written compilation artifact. In the native code backend, for example, this might consult a .cmx file.
val import_symbol : Symbol.t -> Simple_value_approx.tval closure_symbol : Closure_id.t -> Symbol.tThe natural size of an integer on the target architecture (cf. Arch.size_int in the native code backend).
Backend_var.Provenanceval create :
+ module_path:Path.t ->
+ location:Debuginfo.t ->
+ original_ident:Ident.t ->
+ tval location : t -> Debuginfo.tval print : Stdlib.Format.formatter -> t -> unitBackend_var.With_provenanceval print : Stdlib.Format.formatter -> t -> unitval create : ?provenance:Provenance.t -> backend_var -> tval var : t -> backend_varval provenance : t -> Provenance.t optionval name : t -> stringBackend_varVariables used in the backend, optionally equipped with "provenance" information, used for the emission of debugging information.
include module type of struct include Ident endtype t = Ident.tinclude Identifiable.S with type t := tmodule T = Ident.Tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tval output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set = Ident.Setmodule Map = Ident.Mapmodule Tbl = Ident.Tblval print_with_scope : Stdlib.Format.formatter -> t -> unitSame as print except that it will also add a "n" suffix if the scope of the argument is n.
val create_scoped : scope:int -> string -> tval create_local : string -> tval create_persistent : string -> tval create_predef : string -> tCreates an identifier with the same name as the input, a fresh stamp, and no scope.
val name : t -> stringval unique_name : t -> stringval unique_toplevel_name : t -> stringval persistent : t -> boolCompare identifiers by binding location. Two identifiers are the same either if they are both non-persistent and have been created by the same call to create_*, or if they are both persistent and have the same name.
val global : t -> boolval is_predef : t -> boolval scope : t -> inttype 'a tbl = 'a Ident.tblval empty : 'a tbltype backend_var = tmodule Provenance : sig ... endmodule With_provenance : sig ... endBigarrayinclude module type of struct include Stdlib.Bigarray endBigarrays can contain elements of the following kinds:
Bigarray.float32_elt),Bigarray.float64_elt),Bigarray.complex32_elt),Bigarray.complex64_elt),Bigarray.int8_signed_elt or Bigarray.int8_unsigned_elt),Bigarray.int16_signed_elt or Bigarray.int16_unsigned_elt),Bigarray.int_elt),Bigarray.int32_elt),Bigarray.int64_elt),Bigarray.nativeint_elt).Each element kind is represented at the type level by one of the *_elt types defined below (defined with a single constructor instead of abstract types for technical injectivity reasons).
type ('a, 'b) kind = ('a, 'b) Stdlib.Bigarray.kind = | Float32 : (float, float32_elt) kind| Float64 : (float, float64_elt) kind| Int8_signed : (int, int8_signed_elt) kind| Int8_unsigned : (int, int8_unsigned_elt) kind| Int16_signed : (int, int16_signed_elt) kind| Int16_unsigned : (int, int16_unsigned_elt) kind| Int32 : (int32, int32_elt) kind| Int64 : (int64, int64_elt) kind| Int : (int, int_elt) kind| Nativeint : (nativeint, nativeint_elt) kind| Complex32 : (Stdlib.Complex.t, complex32_elt) kind| Complex64 : (Stdlib.Complex.t, complex64_elt) kind| Char : (char, int8_unsigned_elt) kindTo each element kind is associated an OCaml type, which is the type of OCaml values that can be stored in the Bigarray or read back from it. This type is not necessarily the same as the type of the array elements proper: for instance, a Bigarray whose elements are of kind float32_elt contains 32-bit single precision floats, but reading or writing one of its elements from OCaml uses the OCaml type float, which is 64-bit double precision floats.
The GADT type ('a, 'b) kind captures this association of an OCaml type 'a for values read or written in the Bigarray, and of an element kind 'b which represents the actual contents of the Bigarray. Its constructors list all possible associations of OCaml types with element kinds, and are re-exported below for backward-compatibility reasons.
Using a generalized algebraic datatype (GADT) here allows writing well-typed polymorphic functions whose return type depend on the argument type, such as:
let zero : type a b. (a, b) kind -> a = function
+ | Float32 -> 0.0 | Complex32 -> Complex.zero
+ | Float64 -> 0.0 | Complex64 -> Complex.zero
+ | Int8_signed -> 0 | Int8_unsigned -> 0
+ | Int16_signed -> 0 | Int16_unsigned -> 0
+ | Int32 -> 0l | Int64 -> 0L
+ | Int -> 0 | Nativeint -> 0n
+ | Char -> '\000'val float32 : (float, float32_elt) kindSee Bigarray.char.
val float64 : (float, float64_elt) kindSee Bigarray.char.
val complex32 : (Stdlib.Complex.t, complex32_elt) kindSee Bigarray.char.
val complex64 : (Stdlib.Complex.t, complex64_elt) kindSee Bigarray.char.
val int8_signed : (int, int8_signed_elt) kindSee Bigarray.char.
val int8_unsigned : (int, int8_unsigned_elt) kindSee Bigarray.char.
val int16_signed : (int, int16_signed_elt) kindSee Bigarray.char.
val int16_unsigned : (int, int16_unsigned_elt) kindSee Bigarray.char.
See Bigarray.char.
See Bigarray.char.
See Bigarray.char.
val nativeint : (nativeint, nativeint_elt) kindSee Bigarray.char.
val char : (char, int8_unsigned_elt) kindAs shown by the types of the values above, Bigarrays of kind float32_elt and float64_elt are accessed using the OCaml type float. Bigarrays of complex kinds complex32_elt, complex64_elt are accessed with the OCaml type Complex.t. Bigarrays of integer kinds are accessed using the smallest OCaml integer type large enough to represent the array elements: int for 8- and 16-bit integer Bigarrays, as well as OCaml-integer Bigarrays; int32 for 32-bit integer Bigarrays; int64 for 64-bit integer Bigarrays; and nativeint for platform-native integer Bigarrays. Finally, Bigarrays of kind int8_unsigned_elt can also be accessed as arrays of characters instead of arrays of small integers, by using the kind value char instead of int8_unsigned.
val kind_size_in_bytes : ('a, 'b) kind -> intkind_size_in_bytes k is the number of bytes used to store an element of type k.
To facilitate interoperability with existing C and Fortran code, this library supports two different memory layouts for Bigarrays, one compatible with the C conventions, the other compatible with the Fortran conventions.
In the C-style layout, array indices start at 0, and multi-dimensional arrays are laid out in row-major format. That is, for a two-dimensional array, all elements of row 0 are contiguous in memory, followed by all elements of row 1, etc. In other terms, the array elements at (x,y) and (x, y+1) are adjacent in memory.
In the Fortran-style layout, array indices start at 1, and multi-dimensional arrays are laid out in column-major format. That is, for a two-dimensional array, all elements of column 0 are contiguous in memory, followed by all elements of column 1, etc. In other terms, the array elements at (x,y) and (x+1, y) are adjacent in memory.
Each layout style is identified at the type level by the phantom types Bigarray.c_layout and Bigarray.fortran_layout respectively.
The GADT type 'a layout represents one of the two supported memory layouts: C-style or Fortran-style. Its constructors are re-exported as values below for backward-compatibility reasons.
type 'a layout = 'a Stdlib.Bigarray.layout = | C_layout : c_layout layout| Fortran_layout : fortran_layout layoutval fortran_layout : fortran_layout layoutmodule Genarray = Stdlib.Bigarray.Genarraymodule Array0 = Stdlib.Bigarray.Array0Zero-dimensional arrays. The Array0 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of zero-dimensional arrays that only contain a single scalar value. Statically knowing the number of dimensions of the array allows faster operations, and more precise static type-checking.
module Array1 = Stdlib.Bigarray.Array1One-dimensional arrays. The Array1 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of one-dimensional arrays. (The Array2 and Array3 structures below provide operations specialized for two- and three-dimensional arrays.) Statically knowing the number of dimensions of the array allows faster operations, and more precise static type-checking.
module Array2 = Stdlib.Bigarray.Array2Two-dimensional arrays. The Array2 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of two-dimensional arrays.
module Array3 = Stdlib.Bigarray.Array3Three-dimensional arrays. The Array3 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of three-dimensional arrays.
val genarray_of_array0 : ('a, 'b, 'c) Array0.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given zero-dimensional Bigarray.
val genarray_of_array1 : ('a, 'b, 'c) Array1.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given one-dimensional Bigarray.
val genarray_of_array2 : ('a, 'b, 'c) Array2.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given two-dimensional Bigarray.
val genarray_of_array3 : ('a, 'b, 'c) Array3.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given three-dimensional Bigarray.
val array0_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.tReturn the zero-dimensional Bigarray corresponding to the given generic Bigarray.
val array1_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array1.tReturn the one-dimensional Bigarray corresponding to the given generic Bigarray.
val array2_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array2.tReturn the two-dimensional Bigarray corresponding to the given generic Bigarray.
val array3_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array3.tReturn the three-dimensional Bigarray corresponding to the given generic Bigarray.
val reshape : ('a, 'b, 'c) Genarray.t -> int array -> ('a, 'b, 'c) Genarray.treshape b [|d1;...;dN|] converts the Bigarray b to a N-dimensional array of dimensions d1...dN. The returned array and the original array b share their data and have the same layout. For instance, assuming that b is a one-dimensional array of dimension 12, reshape b [|3;4|] returns a two-dimensional array b' of dimensions 3 and 4. If b has C layout, the element (x,y) of b' corresponds to the element x * 3 + y of b. If b has Fortran layout, the element (x,y) of b' corresponds to the element x + (y - 1) * 4 of b. The returned Bigarray must have exactly the same number of elements as the original Bigarray b. That is, the product of the dimensions of b must be equal to i1 * ... * iN. Otherwise, Invalid_argument is raised.
val reshape_0 : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.tSpecialized version of Bigarray.reshape for reshaping to zero-dimensional arrays.
val reshape_1 : ('a, 'b, 'c) Genarray.t -> int -> ('a, 'b, 'c) Array1.tSpecialized version of Bigarray.reshape for reshaping to one-dimensional arrays.
val reshape_2 : ('a, 'b, 'c) Genarray.t -> int -> int -> ('a, 'b, 'c) Array2.tSpecialized version of Bigarray.reshape for reshaping to two-dimensional arrays.
val reshape_3 :
+ ('a, 'b, 'c) Genarray.t ->
+ int ->
+ int ->
+ int ->
+ ('a, 'b, 'c) Array3.tSpecialized version of Bigarray.reshape for reshaping to three-dimensional arrays.
Binutilsval error_to_string : error -> stringval read : string -> (t, error) Stdlib.Result.tval defines_symbol : t -> string -> boolval symbol_offset : t -> string -> int64 optionT.Cond_branchval all : t listval classify_instr : Linear.instruction_desc -> t optionMake.Tmodule Cond_branch : sig ... endval offset_pc_at_branch : distanceval instr_size : Linear.fundecl -> Linear.instruction_desc -> distanceval relax_allocation :
+ num_bytes:int ->
+ dbginfo:Debuginfo.alloc_dbginfo ->
+ Linear.instruction_descval relax_poll : return_label:Cmm.label option -> Linear.instruction_descval relax_intop_checkbound : unit -> Linear.instruction_descval relax_intop_imm_checkbound : bound:int -> Linear.instruction_descval relax_specific_op : Arch.specific_operation -> Linear.instruction_descBranch_relaxation.Makemodule T : Branch_relaxation_intf.Sval relax : Linear.fundecl -> max_out_of_line_code_offset:T.distance -> unitBranch_relaxationmodule Make (T : Branch_relaxation_intf.S) : sig ... endBranch_relaxation_intfmodule type S = sig ... endS.Cond_branchval all : t listval classify_instr : Linear.instruction_desc -> t optionBranch_relaxation_intf.Smodule Cond_branch : sig ... endval offset_pc_at_branch : distanceval instr_size : Linear.fundecl -> Linear.instruction_desc -> distanceval relax_allocation :
+ num_bytes:int ->
+ dbginfo:Debuginfo.alloc_dbginfo ->
+ Linear.instruction_descval relax_poll : return_label:Cmm.label option -> Linear.instruction_descval relax_intop_checkbound : unit -> Linear.instruction_descval relax_intop_imm_checkbound : bound:int -> Linear.instruction_descval relax_specific_op : Arch.specific_operation -> Linear.instruction_descBtype.For_copyval redirect_desc : copy_scope -> Types.type_expr -> Types.type_desc -> unitval with_scope : (copy_scope -> 'a) -> 'aBtype.TransientTypeMaptype key = Types.transient_exprThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Btype.TypeHashinclude Hashtbl.S with type key = Types.transient_exprtype key = Types.transient_exprval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval add : 'a t -> Types.type_expr -> 'a -> unitval find : 'a t -> Types.type_expr -> 'aval iter : (Types.type_expr -> 'a -> unit) -> 'a t -> unitBtype.TypeMapinclude Map.S
+ with type key = Types.transient_expr
+ and type 'a t = 'a TransientTypeMap.ttype key = Types.transient_exprThe type of the map keys.
type 'a t = 'a TransientTypeMap.tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val add : Types.type_expr -> 'a -> 'a t -> 'a tval find : Types.type_expr -> 'a t -> 'aval singleton : Types.type_expr -> 'a -> 'a tval fold : (Types.type_expr -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'bBtype.TypePairsval create : int -> tval clear : t -> unitval add : t -> (Types.type_expr * Types.type_expr) -> unitval mem : t -> (Types.type_expr * Types.type_expr) -> boolval iter : ((Types.type_expr * Types.type_expr) -> unit) -> t -> unitBtype.TypeSetinclude Set.S with type elt = Types.transient_exprtype elt = Types.transient_exprThe type of the set elements.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val add : Types.type_expr -> t -> tval mem : Types.type_expr -> t -> boolval singleton : Types.type_expr -> tval exists : (Types.type_expr -> bool) -> t -> boolval elements : t -> Types.type_expr listBtypemodule TypeSet : sig ... endmodule TransientTypeMap : Map.S with type key = Types.transient_exprmodule TypeMap : sig ... endmodule TypeHash : sig ... endmodule TypePairs : sig ... endval newgenty : Types.type_desc -> Types.type_exprval newgenvar : ?name:string -> unit -> Types.type_exprval newgenstub : scope:int -> Types.type_exprval is_Tvar : Types.type_expr -> boolval is_Tunivar : Types.type_expr -> boolval is_Tconstr : Types.type_expr -> boolval dummy_method : Asttypes.labelval is_fixed : Types.row_desc -> boolval has_fixed_explanation : Types.row_desc -> boolval fixed_explanation : Types.row_desc -> Types.fixed_explanation optionval merge_fixed_explanation :
+ Types.fixed_explanation option ->
+ Types.fixed_explanation option ->
+ Types.fixed_explanation optionval static_row : Types.row_desc -> boolval hash_variant : Asttypes.label -> intval proxy : Types.type_expr -> Types.type_exprval row_of_type : Types.type_expr -> Types.type_exprval has_constr_row : Types.type_expr -> boolval is_constr_row : allow_ident:bool -> Types.type_expr -> boolval set_static_row_name : Types.type_declaration -> Path.t -> unitval iter_type_expr : (Types.type_expr -> unit) -> Types.type_expr -> unitval fold_type_expr :
+ ('a -> Types.type_expr -> 'a) ->
+ 'a ->
+ Types.type_expr ->
+ 'aval iter_row : (Types.type_expr -> unit) -> Types.row_desc -> unitval fold_row : ('a -> Types.type_expr -> 'a) -> 'a -> Types.row_desc -> 'aval iter_abbrev : (Types.type_expr -> unit) -> Types.abbrev_memo -> unitval iter_type_expr_kind :
+ (Types.type_expr -> unit) ->
+ Types.type_decl_kind ->
+ unitval iter_type_expr_cstr_args :
+ (Types.type_expr -> unit) ->
+ Types.constructor_arguments ->
+ unitval map_type_expr_cstr_args :
+ (Types.type_expr -> Types.type_expr) ->
+ Types.constructor_arguments ->
+ Types.constructor_argumentstype type_iterators = {it_signature : type_iterators -> Types.signature -> unit;it_signature_item : type_iterators -> Types.signature_item -> unit;it_value_description : type_iterators -> Types.value_description -> unit;it_type_declaration : type_iterators -> Types.type_declaration -> unit;it_extension_constructor : type_iterators ->
+ Types.extension_constructor ->
+ unit;it_module_declaration : type_iterators -> Types.module_declaration -> unit;it_modtype_declaration : type_iterators -> Types.modtype_declaration -> unit;it_class_declaration : type_iterators -> Types.class_declaration -> unit;it_class_type_declaration : type_iterators ->
+ Types.class_type_declaration ->
+ unit;it_functor_param : type_iterators -> Types.functor_parameter -> unit;it_module_type : type_iterators -> Types.module_type -> unit;it_class_type : type_iterators -> Types.class_type -> unit;it_type_kind : type_iterators -> Types.type_decl_kind -> unit;it_do_type_expr : type_iterators -> Types.type_expr -> unit;it_type_expr : type_iterators -> Types.type_expr -> unit;it_path : Path.t -> unit;}val type_iterators : type_iteratorsval unmark_iterators : type_iteratorsval copy_type_desc :
+ ?keep_names:bool ->
+ (Types.type_expr -> Types.type_expr) ->
+ Types.type_desc ->
+ Types.type_descval copy_row :
+ (Types.type_expr -> Types.type_expr) ->
+ bool ->
+ Types.row_desc ->
+ bool ->
+ Types.type_expr ->
+ Types.row_descmodule For_copy : sig ... endval not_marked_node : Types.type_expr -> boolval logged_mark_node : Types.type_expr -> unitval try_logged_mark_node : Types.type_expr -> boolval flip_mark_node : Types.type_expr -> unitval try_mark_node : Types.type_expr -> boolval mark_type : Types.type_expr -> unitval mark_type_params : Types.type_expr -> unitval unmark_type : Types.type_expr -> unitval unmark_type_decl : Types.type_declaration -> unitval unmark_extension_constructor : Types.extension_constructor -> unitval unmark_class_type : Types.class_type -> unitval unmark_class_signature : Types.class_signature -> unitval find_expans :
+ Asttypes.private_flag ->
+ Path.t ->
+ Types.abbrev_memo ->
+ Types.type_expr optionval memorize_abbrev :
+ Types.abbrev_memo ref ->
+ Asttypes.private_flag ->
+ Path.t ->
+ Types.type_expr ->
+ Types.type_expr ->
+ unitval forget_abbrev : Types.abbrev_memo ref -> Path.t -> unitval snapshot : unit -> Types.snapshotval backtrack : Types.snapshot -> unitval is_optional : Asttypes.arg_label -> boolval label_name : Asttypes.arg_label -> Asttypes.labelval prefixed_label_name : Asttypes.arg_label -> Asttypes.labelval extract_label :
+ Asttypes.label ->
+ (Asttypes.arg_label * 'a) list ->
+ (Asttypes.arg_label * 'a * bool * (Asttypes.arg_label * 'a) list) optionval signature_of_class_type : Types.class_type -> Types.class_signatureval class_body : Types.class_type -> Types.class_typeval scrape_class_type : Types.class_type -> Types.class_typeval class_type_arity : Types.class_type -> intval abbreviate_class_type :
+ Path.t ->
+ Types.type_expr list ->
+ Types.class_type ->
+ Types.class_typeval self_type : Types.class_type -> Types.type_exprval self_type_row : Types.class_type -> Types.type_exprval methods : Types.class_signature -> string listval virtual_methods : Types.class_signature -> string listval concrete_methods : Types.class_signature -> Types.MethSet.tval public_methods : Types.class_signature -> string listval instance_vars : Types.class_signature -> string listval virtual_instance_vars : Types.class_signature -> string listval concrete_instance_vars : Types.class_signature -> Types.VarSet.tval method_type : Asttypes.label -> Types.class_signature -> Types.type_exprval instance_variable_type :
+ Asttypes.label ->
+ Types.class_signature ->
+ Types.type_exprval print_raw : (Stdlib.Format.formatter -> Types.type_expr -> unit) refval cstr_type_path : Types.constructor_description -> Path.tBuild_export_infoConstruct export information, for emission into .cmx files, from an Flambda program.
val build_transient :
+ backend:(module Backend_intf.S) ->
+ Flambda.program ->
+ Export_info.transientBuild_path_prefix_mapRewrite paths for reproducible builds
Warning: this module is unstable and part of compiler-libs.
val encode_prefix : path_prefix -> stringval decode_prefix : string -> (path_prefix, error_message) resultval encode_pair : pair -> stringval decode_pair : string -> (pair, error_message) resulttype map = pair option listval encode_map : map -> stringval decode_map : string -> (map, error_message) resultrewrite_opt map path tries to find a source in map that is a prefix of the input path. If it succeeds, it replaces this prefix with the corresponding target. If it fails, it just returns None.
Builtin_attributesSupport for some of the builtin attributes
Warning: this module is unstable and part of compiler-libs.
val check_alerts : Location.t -> Parsetree.attributes -> string -> unitval check_alerts_inclusion :
+ def:Location.t ->
+ use:Location.t ->
+ Location.t ->
+ Parsetree.attributes ->
+ Parsetree.attributes ->
+ string ->
+ unitval alerts_of_attrs : Parsetree.attributes -> Misc.alertsval alerts_of_sig : Parsetree.signature -> Misc.alertsval alerts_of_str : Parsetree.structure -> Misc.alertsval check_deprecated_mutable :
+ Location.t ->
+ Parsetree.attributes ->
+ string ->
+ unitval check_deprecated_mutable_inclusion :
+ def:Location.t ->
+ use:Location.t ->
+ Location.t ->
+ Parsetree.attributes ->
+ Parsetree.attributes ->
+ string ->
+ unitval check_no_alert : Parsetree.attributes -> unitval error_of_extension : Parsetree.extension -> Location.errorval warning_attribute : ?ppwarning:bool -> Parsetree.attribute -> unitApply warning settings from the specified attribute. "ocaml.warning"/"ocaml.warnerror" (and variants without the prefix) are processed and other attributes are ignored.
Also implement ocaml.ppwarning (unless ~ppwarning:false is passed).
val warning_scope :
+ ?ppwarning:bool ->
+ Parsetree.attributes ->
+ (unit -> 'a) ->
+ 'aExecute a function in a new scope for warning settings. This means that the effect of any call to warning_attribute during the execution of this function will be discarded after execution.
The function also takes a list of attributes which are processed with warning_attribute in the fresh scope before the function is executed.
val warn_on_literal_pattern : Parsetree.attributes -> boolval explicit_arity : Parsetree.attributes -> boolval immediate : Parsetree.attributes -> boolval immediate64 : Parsetree.attributes -> boolval has_unboxed : Parsetree.attributes -> boolval has_boxed : Parsetree.attributes -> boolBytegenval compile_implementation :
+ string ->
+ Lambda.lambda ->
+ Instruct.instruction listval compile_phrase :
+ Lambda.lambda ->
+ Instruct.instruction list * Instruct.instruction listval merge_events :
+ Instruct.debug_event ->
+ Instruct.debug_event ->
+ Instruct.debug_eventBytelibrarianexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitBytelinkval link : Misc.filepath list -> Misc.filepath -> unitval check_consistency : Misc.filepath -> Cmo_format.compilation_unit -> unitval extract_crc_interfaces : unit -> Misc.crcstype error = | File_not_found of Misc.filepath| Not_an_object_file of Misc.filepath| Wrong_object_name of Misc.filepath| Symbol_error of Misc.filepath * Symtable.error| Inconsistent_import of Misc.modname * Misc.filepath * Misc.filepath| Custom_runtime| File_exists of Misc.filepath| Cannot_open_dll of Misc.filepath| Camlheader of string * Misc.filepath| Wrong_link_order of (Misc.modname * Misc.modname) listexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitBytepackagerval package_files :
+ ppf_dump:Stdlib.Format.formatter ->
+ Env.t ->
+ string list ->
+ string ->
+ unitexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitBytesectionsRecording sections written to a bytecode executable file
val init_record : out_channel -> unitval record : out_channel -> string -> unitval write_toc_and_trailer : out_channel -> unitReading sections from a bytecode executable file
val read_toc : in_channel -> unitval seek_section : in_channel -> string -> intval read_section_string : in_channel -> string -> stringval read_section_struct : in_channel -> string -> 'aval pos_first_section : in_channel -> intCSE.cseinherit CSEgen.cse_genericmethod class_of_operation : cse -> Mach.operation -> CSEgen.op_classCSEclass cse : object ... endval fundecl : Mach.fundecl -> Mach.fundeclCSEgen.cse_genericmethod class_of_operation : Mach.operation -> op_classmethod is_cheap_operation : Mach.operation -> boolmethod fundecl : Mach.fundecl -> Mach.fundeclCSEgentype op_class = | Op_pure| Op_checkbound| Op_load of Asttypes.mutable_flag| Op_store of bool| Op_otherclass cse_generic : object ... endCamlinternalAtomicval make : 'a -> 'a tval get : 'a t -> 'aval set : 'a t -> 'a -> unitval exchange : 'a t -> 'a -> 'aval compare_and_set : 'a t -> 'a -> 'a -> boolval fetch_and_add : int t -> int -> intval incr : int t -> unitval decr : int t -> unitCamlinternalFormatval is_in_char_set : CamlinternalFormatBasics.char_set -> char -> boolval rev_char_set :
+ CamlinternalFormatBasics.char_set ->
+ CamlinternalFormatBasics.char_setval create_char_set : unit -> mutable_char_setval add_in_char_set : mutable_char_set -> char -> unitval freeze_char_set : mutable_char_set -> CamlinternalFormatBasics.char_settype ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebb = | Param_format_EBB : ('x -> 'a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f)
+ param_format_ebbval param_format_of_ignored_format :
+ ('a, 'b, 'c, 'd, 'y, 'x) CamlinternalFormatBasics.ignored ->
+ ('x, 'b, 'c, 'y, 'e, 'f) CamlinternalFormatBasics.fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebband ('b, 'c) acc = | Acc_formatting_lit of ('b, 'c) acc * CamlinternalFormatBasics.formatting_lit| Acc_formatting_gen of ('b, 'c) acc * ('b, 'c) acc_formatting_gen| Acc_string_literal of ('b, 'c) acc * string| Acc_char_literal of ('b, 'c) acc * char| Acc_data_string of ('b, 'c) acc * string| Acc_data_char of ('b, 'c) acc * char| Acc_delay of ('b, 'c) acc * 'b -> 'c| Acc_flush of ('b, 'c) acc| Acc_invalid_arg of ('b, 'c) acc * string| End_of_acctype ('a, 'b) heter_list = | Cons : 'c * ('a, 'b) heter_list -> ('c -> 'a, 'b) heter_list| Nil : ('b, 'b) heter_listtype ('b, 'c, 'e, 'f) fmt_ebb = | Fmt_EBB : ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt -> ('b,
+ 'c,
+ 'e,
+ 'f)
+ fmt_ebbval make_printf :
+ (('b, 'c) acc -> 'd) ->
+ ('b, 'c) acc ->
+ ('a, 'b, 'c, 'c, 'c, 'd) CamlinternalFormatBasics.fmt ->
+ 'aval make_iprintf :
+ ('s -> 'f) ->
+ 's ->
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt ->
+ 'aval output_acc : out_channel -> (out_channel, unit) acc -> unitval bufput_acc : Stdlib.Buffer.t -> (Stdlib.Buffer.t, unit) acc -> unitval strput_acc : Stdlib.Buffer.t -> (unit, string) acc -> unitval type_format :
+ ('x, 'b, 'c, 't, 'u, 'v) CamlinternalFormatBasics.fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmtty ->
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmtval fmt_ebb_of_string :
+ ?legacy_behavior:bool ->
+ string ->
+ ('b, 'c, 'e, 'f) fmt_ebbval format_of_string_fmtty :
+ string ->
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmtty ->
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6val format_of_string_format :
+ string ->
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 ->
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6val char_of_iconv : CamlinternalFormatBasics.int_conv -> charval string_of_formatting_lit :
+ CamlinternalFormatBasics.formatting_lit ->
+ stringval string_of_fmtty :
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmtty ->
+ stringval string_of_fmt :
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt ->
+ stringval open_box_of_string : string -> int * CamlinternalFormatBasics.block_typeval symm :
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ CamlinternalFormatBasics.fmtty_rel ->
+ ('a2, 'b2, 'c2, 'd2, 'e2, 'f2, 'a1, 'b1, 'c1, 'd1, 'e1, 'f1)
+ CamlinternalFormatBasics.fmtty_relval trans :
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ CamlinternalFormatBasics.fmtty_rel ->
+ ('a2, 'b2, 'c2, 'd2, 'e2, 'f2, 'a3, 'b3, 'c3, 'd3, 'e3, 'f3)
+ CamlinternalFormatBasics.fmtty_rel ->
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a3, 'b3, 'c3, 'd3, 'e3, 'f3)
+ CamlinternalFormatBasics.fmtty_relval recast :
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1) CamlinternalFormatBasics.fmt ->
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ CamlinternalFormatBasics.fmtty_rel ->
+ ('a2, 'b2, 'c2, 'd2, 'e2, 'f2) CamlinternalFormatBasics.fmtCamlinternalFormatBasicstype float_conv = float_flag_conv * float_kind_convtype ('a, 'b, 'c) custom_arity = | Custom_zero : ('a, string, 'a) custom_arity| Custom_succ : ('a, 'b, 'c) custom_arity -> ('a, 'x -> 'b, 'x -> 'c)
+ custom_aritytype ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen = | Open_tag : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f)
+ formatting_gen| Open_box : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f)
+ formatting_genand ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
+ ('a, 'b, 'c, 'd, 'e, 'f, 'a, 'b, 'c, 'd, 'e, 'f) fmtty_reland ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel = | Char_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (char ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ char ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| String_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (string ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ string ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Int_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1, int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel| Int32_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (int32 ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ int32 ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Nativeint_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (nativeint ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ nativeint ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Int64_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (int64 ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ int64 ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Float_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (float ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ float ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Bool_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (bool ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ bool ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Format_arg_ty : ('g, 'h, 'i, 'j, 'k, 'l) fmtty
+ * ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ ('g, 'h, 'i, 'j, 'k, 'l) format6 ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Format_subst_ty : ('g, 'h, 'i, 'j, 'k, 'l, 'g1, 'b1, 'c1, 'j1, 'd1, 'a1)
+ fmtty_rel
+ * ('g, 'h, 'i, 'j, 'k, 'l, 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel
+ * ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 ->
+ 'g1,
+ 'b1,
+ 'c1,
+ 'j1,
+ 'e1,
+ 'f1,
+ ('g, 'h, 'i, 'j, 'k, 'l) format6 ->
+ 'g2,
+ 'b2,
+ 'c2,
+ 'j2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Alpha_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (('b1 -> 'x -> 'c1) ->
+ 'x ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ ('b2 -> 'x -> 'c2) ->
+ 'x ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Theta_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> (('b1 -> 'c1) ->
+ 'a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ ('b2 -> 'c2) ->
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Any_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ ('x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel| Reader_ty : ('a1, 'b1, 'c1, 'd1, 'e1, 'f1, 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)
+ fmtty_rel -> ('x ->
+ 'a1,
+ 'b1,
+ 'c1,
+ ('b1 -> 'x) ->
+ 'd1,
+ 'e1,
+ 'f1,
+ 'x ->
+ 'a2,
+ 'b2,
+ 'c2,
+ ('b2 -> 'x) ->
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| Ignored_reader_ty : ('a1,
+ 'b1,
+ 'c1,
+ 'd1,
+ 'e1,
+ 'f1,
+ 'a2,
+ 'b2,
+ 'c2,
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel -> ('a1,
+ 'b1,
+ 'c1,
+ ('b1 -> 'x) ->
+ 'd1,
+ 'e1,
+ 'f1,
+ 'a2,
+ 'b2,
+ 'c2,
+ ('b2 -> 'x) ->
+ 'd2,
+ 'e2,
+ 'f2)
+ fmtty_rel| End_of_fmtty : ('f1, 'b1, 'c1, 'd1, 'd1, 'f1, 'f2, 'b2, 'c2, 'd2, 'd2, 'f2)
+ fmtty_reland ('a, 'b, 'c, 'd, 'e, 'f) fmt = | Char : ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt| Caml_char : ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (char -> 'a, 'b, 'c, 'd, 'e, 'f)
+ fmt| String : ('x, string -> 'a) padding
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Caml_string : ('x, string -> 'a) padding
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Int : int_conv
+ * ('x, 'y) padding
+ * ('y, int -> 'a) precision
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Int32 : int_conv
+ * ('x, 'y) padding
+ * ('y, int32 -> 'a) precision
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Nativeint : int_conv
+ * ('x, 'y) padding
+ * ('y, nativeint -> 'a) precision
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Int64 : int_conv
+ * ('x, 'y) padding
+ * ('y, int64 -> 'a) precision
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Float : float_conv
+ * ('x, 'y) padding
+ * ('y, float -> 'a) precision
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Bool : ('x, bool -> 'a) padding
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x, 'b, 'c, 'd, 'e, 'f) fmt| Flush : ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('a, 'b, 'c, 'd, 'e, 'f) fmt| String_literal : string
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('a, 'b, 'c, 'd, 'e, 'f) fmt| Char_literal : char
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('a, 'b, 'c, 'd, 'e, 'f) fmt| Format_arg : pad_option
+ * ('g, 'h, 'i, 'j, 'k, 'l) fmtty
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (('g, 'h, 'i, 'j, 'k, 'l) format6 ->
+ 'a,
+ 'b,
+ 'c,
+ 'd,
+ 'e,
+ 'f)
+ fmt| Format_subst : pad_option
+ * ('g, 'h, 'i, 'j, 'k, 'l, 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (('g, 'h, 'i, 'j, 'k, 'l) format6 ->
+ 'g2,
+ 'b,
+ 'c,
+ 'j2,
+ 'e,
+ 'f)
+ fmt| Alpha : ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (('b -> 'x -> 'c) ->
+ 'x ->
+ 'a,
+ 'b,
+ 'c,
+ 'd,
+ 'e,
+ 'f)
+ fmt| Theta : ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f)
+ fmt| Formatting_lit : formatting_lit
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('a, 'b, 'c, 'd, 'e, 'f) fmt| Formatting_gen : ('a1, 'b, 'c, 'd1, 'e1, 'f1) formatting_gen
+ * ('f1, 'b, 'c, 'e1, 'e2, 'f2) fmt -> ('a1, 'b, 'c, 'd1, 'e2, 'f2) fmt| Reader : ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('x ->
+ 'a,
+ 'b,
+ 'c,
+ ('b -> 'x) ->
+ 'd,
+ 'e,
+ 'f)
+ fmt| Scan_char_set : pad_option
+ * char_set
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt| Scan_get_counter : counter
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt| Scan_next_char : ('a, 'b, 'c, 'd, 'e, 'f) fmt -> (char ->
+ 'a,
+ 'b,
+ 'c,
+ 'd,
+ 'e,
+ 'f)
+ fmt| Ignored_param : ('a, 'b, 'c, 'd, 'y, 'x) ignored
+ * ('x, 'b, 'c, 'y, 'e, 'f) fmt -> ('a, 'b, 'c, 'd, 'e, 'f) fmt| Custom : ('a, 'x, 'y) custom_arity
+ * (unit ->
+ 'x)
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmt -> ('y, 'b, 'c, 'd, 'e, 'f) fmt| End_of_format : ('f, 'b, 'c, 'e, 'e, 'f) fmtList of format elements.
and ('a, 'b, 'c, 'd, 'e, 'f) ignored = | Ignored_char : ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_caml_char : ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_string : pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_caml_string : pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_int : int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_int32 : int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_nativeint : int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_int64 : int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_float : pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_bool : pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_format_arg : pad_option
+ * ('g, 'h, 'i, 'j, 'k, 'l) fmtty -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_format_subst : pad_option
+ * ('a, 'b, 'c, 'd, 'e, 'f) fmtty -> ('a, 'b, 'c, 'd, 'e, 'f) ignored| Ignored_reader : ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored| Ignored_scan_char_set : pad_option
+ * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_scan_get_counter : counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored| Ignored_scan_next_char : ('a, 'b, 'c, 'd, 'd, 'a) ignoredCamlinternalLazyRun-time support for lazy values. All functions in this module are for system use only, not for the casual user.
Convert.Simplifiedval traditional2revised :
+ ('token, 'semantic_value) traditional ->
+ ('token * Stdlib.Lexing.position * Stdlib.Lexing.position, 'semantic_value)
+ revisedval revised2traditional :
+ ('token * Stdlib.Lexing.position * Stdlib.Lexing.position, 'semantic_value)
+ revised ->
+ ('token, 'semantic_value) traditionalCamlinternalMenhirLib.Converttype ('token, 'semantic_value) traditional =
+ (Stdlib.Lexing.lexbuf -> 'token) ->
+ Stdlib.Lexing.lexbuf ->
+ 'semantic_valueval traditional2revised :
+ ('token -> 'raw_token) ->
+ ('token -> Stdlib.Lexing.position) ->
+ ('token -> Stdlib.Lexing.position) ->
+ ('raw_token, 'semantic_value) traditional ->
+ ('token, 'semantic_value) revisedval revised2traditional :
+ ('raw_token -> Stdlib.Lexing.position -> Stdlib.Lexing.position -> 'token) ->
+ ('token, 'semantic_value) revised ->
+ ('raw_token, 'semantic_value) traditionalmodule Simplified : sig ... endT.Logval state : state -> unitval reduce_or_accept : production -> unitval lookahead_token :
+ terminal ->
+ Stdlib.Lexing.position ->
+ Stdlib.Lexing.position ->
+ unitval handling_error : state -> unitMake.Tval number : state -> intval token2value : token -> semantic_valueval error_terminal : terminalval error_value : semantic_valueval foreach_terminal : (terminal -> 'a -> 'a) -> 'a -> 'aval production_index : production -> intval find_production : int -> productionval default_reduction :
+ state ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval action :
+ state ->
+ terminal ->
+ semantic_value ->
+ ('env -> bool -> terminal -> semantic_value -> state -> 'answer) ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval goto_nt : state -> nonterminal -> stateval goto_prod : state -> production -> stateval maybe_goto_nt : state -> nonterminal -> state optionval is_start : production -> booltype semantic_action =
+ (state, semantic_value, token) EngineTypes.env ->
+ (state, semantic_value) EngineTypes.stackval semantic_action : production -> semantic_actionval may_reduce : state -> production -> boolmodule Log : sig ... endEngine.Makemodule T : EngineTypes.TABLEinclude EngineTypes.MONOLITHIC_ENGINE
+ with type state = T.state
+ with type token = T.token
+ with type semantic_value = T.semantic_valuetype state = T.statetype token = T.tokentype semantic_value = T.semantic_valueval entry :
+ [ `Legacy | `Simplified ] ->
+ state ->
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ semantic_valueinclude IncrementalEngine.INCREMENTAL_ENGINE
+ with type token := token
+ and type 'a lr1state = state
+ with type production = T.production
+ with type 'a env = (T.state, T.semantic_value, T.token) EngineTypes.envtype production = T.productiontype 'a env = (T.state, T.semantic_value, T.token) EngineTypes.envval offer :
+ 'a checkpoint ->
+ (token * IncrementalEngine.position * IncrementalEngine.position) ->
+ 'a checkpointval resume : ?strategy:strategy -> 'a checkpoint -> 'a checkpointtype supplier =
+ unit ->
+ token * IncrementalEngine.position * IncrementalEngine.positionval lexer_lexbuf_to_supplier :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ supplierval loop : ?strategy:strategy -> supplier -> 'a checkpoint -> 'aval loop_handle :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval loop_handle_undo :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval shifts : 'a checkpoint -> 'a env optionval acceptable : 'a checkpoint -> token -> IncrementalEngine.position -> booltype 'a lr1state = stateval number : _ lr1state -> intval production_index : production -> intval find_production : int -> productiontype element = | Element : 'a lr1state
+ * 'a
+ * IncrementalEngine.position
+ * IncrementalEngine.position -> elementtype stack = element General.streamval current_state_number : 'a env -> intval positions :
+ 'a env ->
+ IncrementalEngine.position * IncrementalEngine.positionval env_has_default_reduction : 'a env -> boolval state_has_default_reduction : _ lr1state -> boolval force_reduction : production -> 'a env -> 'a envval input_needed : 'a env -> 'a checkpointinclude EngineTypes.INCREMENTAL_ENGINE_START
+ with type state := state
+ and type semantic_value := semantic_value
+ and type 'a checkpoint := 'a checkpointval start : state -> Stdlib.Lexing.position -> semantic_value checkpointCamlinternalMenhirLib.Enginemodule Make
+ (T : EngineTypes.TABLE) :
+ EngineTypes.ENGINE
+ with type state = T.state
+ and type token = T.token
+ and type semantic_value = T.semantic_value
+ and type production = T.production
+ and type 'a env = (T.state, T.semantic_value, T.token) EngineTypes.envCamlinternalMenhirLib.EngineTypestype ('state, 'semantic_value) stack = {state : 'state;semv : 'semantic_value;startp : Stdlib.Lexing.position;endp : Stdlib.Lexing.position;next : ('state, 'semantic_value) stack;}type ('state, 'semantic_value, 'token) env = {error : bool;triple : 'token * Stdlib.Lexing.position * Stdlib.Lexing.position;stack : ('state, 'semantic_value) stack;current : 'state;}module type TABLE = sig ... endmodule type MONOLITHIC_ENGINE = sig ... endmodule type INCREMENTAL_ENGINE_START = sig ... endmodule type ENGINE = sig ... endEngineTypes.ENGINEinclude MONOLITHIC_ENGINEval entry :
+ [ `Legacy | `Simplified ] ->
+ state ->
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ semantic_valueinclude IncrementalEngine.INCREMENTAL_ENGINE
+ with type token := token
+ and type 'a lr1state = stateval offer :
+ 'a checkpoint ->
+ (token * IncrementalEngine.position * IncrementalEngine.position) ->
+ 'a checkpointval resume : ?strategy:strategy -> 'a checkpoint -> 'a checkpointtype supplier =
+ unit ->
+ token * IncrementalEngine.position * IncrementalEngine.positionval lexer_lexbuf_to_supplier :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ supplierval loop : ?strategy:strategy -> supplier -> 'a checkpoint -> 'aval loop_handle :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval loop_handle_undo :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval shifts : 'a checkpoint -> 'a env optionval acceptable : 'a checkpoint -> token -> IncrementalEngine.position -> booltype 'a lr1state = stateval number : _ lr1state -> intval production_index : production -> intval find_production : int -> productiontype element = | Element : 'a lr1state
+ * 'a
+ * IncrementalEngine.position
+ * IncrementalEngine.position -> elementtype stack = element General.streamval current_state_number : 'a env -> intval positions :
+ 'a env ->
+ IncrementalEngine.position * IncrementalEngine.positionval env_has_default_reduction : 'a env -> boolval state_has_default_reduction : _ lr1state -> boolval force_reduction : production -> 'a env -> 'a envval input_needed : 'a env -> 'a checkpointinclude INCREMENTAL_ENGINE_START
+ with type state := state
+ and type semantic_value := semantic_value
+ and type 'a checkpoint := 'a checkpointval start : state -> Stdlib.Lexing.position -> semantic_value checkpointEngineTypes.INCREMENTAL_ENGINE_STARTval start : state -> Stdlib.Lexing.position -> semantic_value checkpointEngineTypes.MONOLITHIC_ENGINEval entry :
+ [ `Legacy | `Simplified ] ->
+ state ->
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ semantic_valueTABLE.Logval state : state -> unitval reduce_or_accept : production -> unitval lookahead_token :
+ terminal ->
+ Stdlib.Lexing.position ->
+ Stdlib.Lexing.position ->
+ unitval handling_error : state -> unitEngineTypes.TABLEval number : state -> intval token2value : token -> semantic_valueval error_terminal : terminalval error_value : semantic_valueval foreach_terminal : (terminal -> 'a -> 'a) -> 'a -> 'aval production_index : production -> intval find_production : int -> productionval default_reduction :
+ state ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval action :
+ state ->
+ terminal ->
+ semantic_value ->
+ ('env -> bool -> terminal -> semantic_value -> state -> 'answer) ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval goto_nt : state -> nonterminal -> stateval goto_prod : state -> production -> stateval maybe_goto_nt : state -> nonterminal -> state optionval is_start : production -> booltype semantic_action =
+ (state, semantic_value, token) env ->
+ (state, semantic_value) stackval semantic_action : production -> semantic_actionval may_reduce : state -> production -> boolmodule Log : sig ... endCamlinternalMenhirLib.ErrorReportsval wrap :
+ (Stdlib.Lexing.lexbuf -> 'token) ->
+ (Stdlib.Lexing.position * Stdlib.Lexing.position) buffer
+ * (Stdlib.Lexing.lexbuf ->
+ 'token)val wrap_supplier :
+ (unit -> 'token * Stdlib.Lexing.position * Stdlib.Lexing.position) ->
+ (Stdlib.Lexing.position * Stdlib.Lexing.position) buffer
+ * (unit ->
+ 'token * Stdlib.Lexing.position * Stdlib.Lexing.position)val show : ('a -> string) -> 'a buffer -> stringval last : 'a buffer -> 'aval extract :
+ string ->
+ (Stdlib.Lexing.position * Stdlib.Lexing.position) ->
+ stringCamlinternalMenhirLib.Generaltype 'a stream = 'a head Stdlib.Lazy.tval length : 'a stream -> intval foldr : ('a -> 'b -> 'b) -> 'a stream -> 'b -> 'bCamlinternalMenhirLib.IncrementalEnginetype position = Stdlib.Lexing.positionmodule type INCREMENTAL_ENGINE = sig ... endmodule type SYMBOLS = sig ... endmodule type INSPECTION = sig ... endmodule type EVERYTHING = sig ... endIncrementalEngine.EVERYTHINGinclude INCREMENTAL_ENGINEval offer : 'a checkpoint -> (token * position * position) -> 'a checkpointval resume : ?strategy:strategy -> 'a checkpoint -> 'a checkpointval lexer_lexbuf_to_supplier :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ supplierval loop : ?strategy:strategy -> supplier -> 'a checkpoint -> 'aval loop_handle :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval loop_handle_undo :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval shifts : 'a checkpoint -> 'a env optionval acceptable : 'a checkpoint -> token -> position -> boolval number : _ lr1state -> intval production_index : production -> intval find_production : int -> productiontype stack = element General.streamval current_state_number : 'a env -> intval env_has_default_reduction : 'a env -> boolval state_has_default_reduction : _ lr1state -> boolval force_reduction : production -> 'a env -> 'a envval input_needed : 'a env -> 'a checkpointinclude INSPECTION
+ with type 'a lr1state := 'a lr1state
+ with type production := production
+ with type 'a env := 'a envtype item = production * intval compare_nonterminals : _ nonterminal -> _ nonterminal -> intval compare_productions : production -> production -> intval lhs : production -> xsymbolval rhs : production -> xsymbol listval nullable : _ nonterminal -> boolval first : _ nonterminal -> _ terminal -> boolval foreach_terminal : (xsymbol -> 'a -> 'a) -> 'a -> 'aval foreach_terminal_but_error : (xsymbol -> 'a -> 'a) -> 'a -> 'aIncrementalEngine.INCREMENTAL_ENGINEval offer : 'a checkpoint -> (token * position * position) -> 'a checkpointval resume : ?strategy:strategy -> 'a checkpoint -> 'a checkpointval lexer_lexbuf_to_supplier :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ supplierval loop : ?strategy:strategy -> supplier -> 'a checkpoint -> 'aval loop_handle :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval loop_handle_undo :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval shifts : 'a checkpoint -> 'a env optionval acceptable : 'a checkpoint -> token -> position -> boolval number : _ lr1state -> intval production_index : production -> intval find_production : int -> productiontype stack = element General.streamval current_state_number : 'a env -> intval env_has_default_reduction : 'a env -> boolval state_has_default_reduction : _ lr1state -> boolval force_reduction : production -> 'a env -> 'a envval input_needed : 'a env -> 'a checkpointIncrementalEngine.INSPECTIONtype item = production * intval compare_nonterminals : _ nonterminal -> _ nonterminal -> intval compare_productions : production -> production -> intval lhs : production -> xsymbolval rhs : production -> xsymbol listval nullable : _ nonterminal -> boolval first : _ nonterminal -> _ terminal -> boolval foreach_terminal : (xsymbol -> 'a -> 'a) -> 'a -> 'aval foreach_terminal_but_error : (xsymbol -> 'a -> 'a) -> 'a -> 'aIncrementalEngine.SYMBOLSCamlinternalMenhirLib.InfiniteArrayval make : 'a -> 'a tmake x creates an infinite array, where every slot contains x. *
val get : 'a t -> int -> 'aget a i returns the element contained at offset i in the array a. Slots are numbered 0 and up. *
val set : 'a t -> int -> 'a -> unitset a i x sets the element contained at offset i in the array a to x. Slots are numbered 0 and up. *
val extent : 'a t -> intextent a is the length of an initial segment of the array a that is sufficiently large to contain all set operations ever performed. In other words, all elements beyond that segment have the default value.
val domain : 'a t -> 'a arraydomain a is a fresh copy of an initial segment of the array a whose length is extent a.
CamlinternalMenhirLib.InspectionTableFormatmodule type TABLES = sig ... endInspectionTableFormat.TABLESinclude IncrementalEngine.SYMBOLSval terminal : int -> xsymbolval nonterminal : int -> xsymbolval rhs : PackedIntArray.t * PackedIntArray.tval lr0_core : PackedIntArray.tval lr0_items : PackedIntArray.t * PackedIntArray.tval lr0_incoming : PackedIntArray.tMake.TTval token2terminal : token -> intval token2value : token -> Stdlib.Obj.tval default_reduction : PackedIntArray.tval action : PackedIntArray.t * PackedIntArray.tval lhs : PackedIntArray.tval goto : PackedIntArray.t * PackedIntArray.tval semantic_action :
+ ((int, Stdlib.Obj.t, token) EngineTypes.env ->
+ (int, Stdlib.Obj.t) EngineTypes.stack)
+ arrayMake.ITinclude IncrementalEngine.SYMBOLSval terminal : int -> xsymbolval nonterminal : int -> xsymbolval rhs : PackedIntArray.t * PackedIntArray.tval lr0_core : PackedIntArray.tval lr0_items : PackedIntArray.t * PackedIntArray.tval lr0_incoming : PackedIntArray.tET.Logval state : state -> unitval reduce_or_accept : production -> unitval lookahead_token :
+ terminal ->
+ Stdlib.Lexing.position ->
+ Stdlib.Lexing.position ->
+ unitval handling_error : state -> unitMake.ETval number : state -> inttype semantic_value = Stdlib.Obj.tval token2value : token -> semantic_valueval error_terminal : terminalval error_value : semantic_valueval foreach_terminal : (terminal -> 'a -> 'a) -> 'a -> 'aval production_index : production -> intval find_production : int -> productionval default_reduction :
+ state ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval action :
+ state ->
+ terminal ->
+ semantic_value ->
+ ('env -> bool -> terminal -> semantic_value -> state -> 'answer) ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval goto_nt : state -> nonterminal -> stateval goto_prod : state -> production -> stateval maybe_goto_nt : state -> nonterminal -> state optionval is_start : production -> booltype semantic_action =
+ (state, semantic_value, token) EngineTypes.env ->
+ (state, semantic_value) EngineTypes.stackval semantic_action : production -> semantic_actionval may_reduce : state -> production -> boolmodule Log : sig ... endMake.Etype 'a env = (ET.state, ET.semantic_value, ET.token) EngineTypes.envInspectionTableInterpreter.Makemodule TT : TableFormat.TABLESmodule IT : InspectionTableFormat.TABLES with type 'a lr1state = intmodule ET :
+ EngineTypes.TABLE
+ with type terminal = int
+ and type nonterminal = int
+ and type semantic_value = Stdlib.Obj.tmodule E : sig ... endinclude IncrementalEngine.SYMBOLS
+ with type 'a terminal := 'a IT.terminal
+ with type 'a nonterminal := 'a IT.nonterminalval compare_terminals : _ IT.terminal -> _ IT.terminal -> intval compare_nonterminals : _ IT.nonterminal -> _ IT.nonterminal -> intval incoming_symbol : 'a IT.lr1state -> 'a symbolval items : _ IT.lr1state -> item listval lhs : int -> xsymbolval rhs : int -> xsymbol listval nullable : _ IT.nonterminal -> boolval first : _ IT.nonterminal -> _ IT.terminal -> boolval xfirst : xsymbol -> _ IT.terminal -> boolval foreach_terminal : (xsymbol -> 'a -> 'a) -> 'a -> 'aval foreach_terminal_but_error : (xsymbol -> 'a -> 'a) -> 'a -> 'aval feed :
+ 'a symbol ->
+ IncrementalEngine.position ->
+ 'a ->
+ IncrementalEngine.position ->
+ 'b E.env ->
+ 'b E.envSymbols.TInspectionTableInterpreter.SymbolsCamlinternalMenhirLib.InspectionTableInterpretermodule Symbols
+ (T : sig ... end) :
+ IncrementalEngine.SYMBOLS
+ with type 'a terminal := 'a T.terminal
+ and type 'a nonterminal := 'a T.nonterminalmodule Make
+ (TT : TableFormat.TABLES)
+ (IT : InspectionTableFormat.TABLES with type 'a lr1state = int)
+ (ET :
+ EngineTypes.TABLE
+ with type terminal = int
+ and type nonterminal = int
+ and type semantic_value = Stdlib.Obj.t)
+ (E : sig ... end) :
+ IncrementalEngine.INSPECTION
+ with type 'a terminal := 'a IT.terminal
+ and type 'a nonterminal := 'a IT.nonterminal
+ and type 'a lr1state := 'a IT.lr1state
+ and type production := int
+ and type 'a env := 'a E.envCamlinternalMenhirLib.LexerUtilval init : string -> Stdlib.Lexing.lexbuf -> Stdlib.Lexing.lexbufval read : string -> string * Stdlib.Lexing.lexbufval newline : Stdlib.Lexing.lexbuf -> unitval range : (Stdlib.Lexing.position * Stdlib.Lexing.position) -> stringCamlinternalMenhirLib.LinearizedArrayval make : 'a array array -> 'a tval read : 'a t -> int -> int -> 'aval write : 'a t -> int -> int -> 'a -> unitval length : 'a t -> intval row_length : 'a t -> int -> intval read_row : 'a t -> int -> 'a listCamlinternalMenhirLib.PackedIntArrayMake.Iinclude IncrementalEngine.INCREMENTAL_ENGINEval offer :
+ 'a checkpoint ->
+ (token * IncrementalEngine.position * IncrementalEngine.position) ->
+ 'a checkpointval resume : ?strategy:strategy -> 'a checkpoint -> 'a checkpointtype supplier =
+ unit ->
+ token * IncrementalEngine.position * IncrementalEngine.positionval lexer_lexbuf_to_supplier :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ supplierval loop : ?strategy:strategy -> supplier -> 'a checkpoint -> 'aval loop_handle :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval loop_handle_undo :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval shifts : 'a checkpoint -> 'a env optionval acceptable : 'a checkpoint -> token -> IncrementalEngine.position -> boolval number : _ lr1state -> intval production_index : production -> intval find_production : int -> productiontype element = | Element : 'a lr1state
+ * 'a
+ * IncrementalEngine.position
+ * IncrementalEngine.position -> elementtype stack = element General.streamval current_state_number : 'a env -> intval positions :
+ 'a env ->
+ IncrementalEngine.position * IncrementalEngine.positionval env_has_default_reduction : 'a env -> boolval state_has_default_reduction : _ lr1state -> boolval force_reduction : production -> 'a env -> 'a envval input_needed : 'a env -> 'a checkpointinclude IncrementalEngine.INSPECTION
+ with type 'a lr1state := 'a lr1state
+ with type production := production
+ with type 'a env := 'a envinclude IncrementalEngine.SYMBOLStype item = production * intval compare_nonterminals : _ nonterminal -> _ nonterminal -> intval compare_productions : production -> production -> intval lhs : production -> xsymbolval rhs : production -> xsymbol listval nullable : _ nonterminal -> boolval first : _ nonterminal -> _ terminal -> boolval foreach_terminal : (xsymbol -> 'a -> 'a) -> 'a -> 'aval foreach_terminal_but_error : (xsymbol -> 'a -> 'a) -> 'a -> 'aval feed :
+ 'a symbol ->
+ IncrementalEngine.position ->
+ 'a ->
+ IncrementalEngine.position ->
+ 'b env ->
+ 'b envMake.UserPrinters.Makemodule I : IncrementalEngine.EVERYTHINGmodule User : sig ... endval print_symbols : I.xsymbol list -> unitval print_element_as_symbol : I.element -> unitval print_stack : 'a I.env -> unitval print_item : I.item -> unitval print_production : I.production -> unitval print_current_state : 'a I.env -> unitval print_env : 'a I.env -> unitCamlinternalMenhirLib.Printersmodule Make
+ (I : IncrementalEngine.EVERYTHING)
+ (User : sig ... end) :
+ sig ... endCamlinternalMenhirLib.RowDisplacementval compress :
+ ('a -> 'a -> bool) ->
+ ('a -> bool) ->
+ 'a ->
+ int ->
+ int ->
+ 'a array array ->
+ 'a tableval get : 'a table -> int -> int -> 'aCamlinternalMenhirLib.StaticVersionCamlinternalMenhirLib.TableFormatmodule type TABLES = sig ... endTableFormat.TABLESval token2terminal : token -> intval token2value : token -> Stdlib.Obj.tval default_reduction : PackedIntArray.tval action : PackedIntArray.t * PackedIntArray.tval lhs : PackedIntArray.tval goto : PackedIntArray.t * PackedIntArray.tval semantic_action :
+ ((int, Stdlib.Obj.t, token) EngineTypes.env ->
+ (int, Stdlib.Obj.t) EngineTypes.stack)
+ arrayMakeEngineTable.Logval state : state -> unitval reduce_or_accept : production -> unitval lookahead_token :
+ terminal ->
+ Stdlib.Lexing.position ->
+ Stdlib.Lexing.position ->
+ unitval handling_error : state -> unitMakeEngineTable.Tval token2terminal : token -> intval token2value : token -> Stdlib.Obj.tval default_reduction : PackedIntArray.tval action : PackedIntArray.t * PackedIntArray.tval lhs : PackedIntArray.tval goto : PackedIntArray.t * PackedIntArray.tval semantic_action :
+ ((int, Stdlib.Obj.t, token) EngineTypes.env ->
+ (int, Stdlib.Obj.t) EngineTypes.stack)
+ arrayTableInterpreter.MakeEngineTablemodule T : TableFormat.TABLESval number : state -> inttype token = T.tokentype semantic_value = Stdlib.Obj.tval token2value : token -> semantic_valueval error_terminal : terminalval error_value : semantic_valueval foreach_terminal : (terminal -> 'a -> 'a) -> 'a -> 'aval production_index : production -> intval find_production : int -> productionval default_reduction :
+ state ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval action :
+ state ->
+ terminal ->
+ semantic_value ->
+ ('env -> bool -> terminal -> semantic_value -> state -> 'answer) ->
+ ('env -> production -> 'answer) ->
+ ('env -> 'answer) ->
+ 'env ->
+ 'answerval goto_nt : state -> nonterminal -> stateval goto_prod : state -> production -> stateval maybe_goto_nt : state -> nonterminal -> state optionval is_start : production -> booltype semantic_action =
+ (state, semantic_value, token) EngineTypes.env ->
+ (state, semantic_value) EngineTypes.stackval semantic_action : production -> semantic_actionval may_reduce : state -> production -> boolmodule Log : sig ... endCamlinternalMenhirLib.TableInterpretermodule MakeEngineTable
+ (T : TableFormat.TABLES) :
+ EngineTypes.TABLE
+ with type state = int
+ and type token = T.token
+ and type semantic_value = Stdlib.Obj.t
+ and type production = int
+ and type terminal = int
+ and type nonterminal = intCamlinternalMenhirLibmodule General : sig ... endmodule Convert : sig ... endmodule IncrementalEngine : sig ... endmodule EngineTypes : sig ... endmodule Engine : sig ... endmodule ErrorReports : sig ... endmodule LexerUtil : sig ... endmodule Printers : sig ... endmodule InfiniteArray : sig ... endmodule PackedIntArray : sig ... endmodule RowDisplacement : sig ... endmodule LinearizedArray : sig ... endmodule TableFormat : sig ... endmodule InspectionTableFormat : sig ... endmodule InspectionTableInterpreter : sig ... endmodule TableInterpreter : sig ... endmodule StaticVersion : sig ... endCamlinternalModRun-time support for recursive modules. All functions in this module are for system use only, not for the casual user.
val init_mod : (string * int * int) -> shape -> Stdlib.Obj.tval update_mod : shape -> Stdlib.Obj.t -> Stdlib.Obj.t -> unitCamlinternalOORun-time support for objects and classes. All functions in this module are for system use only, not for the casual user.
val public_method_label : string -> tagval new_variable : table -> string -> intval get_variable : table -> string -> intval get_variables : table -> string array -> int arrayval narrow : table -> string array -> string array -> string array -> unitval widen : table -> unitval dummy_table : tableval create_table : string array -> tableval init_class : table -> unitval inherits :
+ table ->
+ string array ->
+ string array ->
+ string array ->
+ (t * (table -> obj -> Stdlib.Obj.t) * t * obj) ->
+ bool ->
+ Stdlib.Obj.t arrayval make_class :
+ string array ->
+ (table -> Stdlib.Obj.t -> t) ->
+ t * (table -> Stdlib.Obj.t -> t) * (Stdlib.Obj.t -> t) * Stdlib.Obj.tval make_class_store : string array -> (table -> t) -> init_table -> unitval dummy_class :
+ (string * int * int) ->
+ t * (table -> Stdlib.Obj.t -> t) * (Stdlib.Obj.t -> t) * Stdlib.Obj.ttype impl = | GetConst| GetVar| GetEnv| GetMeth| SetVar| AppConst| AppVar| AppEnv| AppMeth| AppConstConst| AppConstVar| AppConstEnv| AppConstMeth| AppVarConst| AppEnvConst| AppMethConst| MethAppConst| MethAppVar| MethAppEnv| MethAppMeth| SendConst| SendVar| SendEnv| SendMeth| Closure of closureval params : paramsval stats : unit -> statsCcompCompiling C files and building C libraries
Warning: this module is unstable and part of compiler-libs.
val call_linker : link_mode -> string -> string list -> string -> intClambdaand uphantom_defining_expr = | Uphantom_const of uconstantThe phantom-let-bound variable is a constant.
*)| Uphantom_var of Backend_var.tThe phantom-let-bound variable is an alias for another variable.
*)| Uphantom_offset_var of {var : Backend_var.t;offset_in_words : int;}The phantom-let-bound-variable's value is defined by adding the given number of words to the pointer contained in the given identifier.
*)| Uphantom_read_field of {var : Backend_var.t;field : int;}The phantom-let-bound-variable's value is found by adding the given number of words to the pointer contained in the given identifier, then dereferencing.
*)| Uphantom_read_symbol_field of {}As for Uphantom_read_var_field, but with the pointer specified by a symbol.
| Uphantom_block of {tag : int;fields : Backend_var.t list;}The phantom-let-bound variable points at a block with the given structure.
*)and ulambda = | Uvar of Backend_var.t| Uconst of uconstant| Udirect_apply of function_label * ulambda list * Debuginfo.t| Ugeneric_apply of ulambda * ulambda list * Debuginfo.t| Uclosure of ufunction list * ulambda list| Uoffset of ulambda * int| Ulet of Asttypes.mutable_flag
+ * Lambda.value_kind
+ * Backend_var.With_provenance.t
+ * ulambda
+ * ulambda| Uphantom_let of Backend_var.With_provenance.t
+ * uphantom_defining_expr option
+ * ulambda| Uletrec of (Backend_var.With_provenance.t * ulambda) list * ulambda| Uprim of Clambda_primitives.primitive * ulambda list * Debuginfo.t| Uswitch of ulambda * ulambda_switch * Debuginfo.t| Ustringswitch of ulambda * (string * ulambda) list * ulambda option| Ustaticfail of int * ulambda list| Ucatch of int
+ * (Backend_var.With_provenance.t * Lambda.value_kind) list
+ * ulambda
+ * ulambda| Utrywith of ulambda * Backend_var.With_provenance.t * ulambda| Uifthenelse of ulambda * ulambda * ulambda| Usequence of ulambda * ulambda| Uwhile of ulambda * ulambda| Ufor of Backend_var.With_provenance.t
+ * ulambda
+ * ulambda
+ * Asttypes.direction_flag
+ * ulambda| Uassign of Backend_var.t * ulambda| Usend of Lambda.meth_kind * ulambda * ulambda * ulambda list * Debuginfo.t| Uunreachableand ufunction = {label : function_label;arity : int;params : (Backend_var.With_provenance.t * Lambda.value_kind) list;return : Lambda.value_kind;body : ulambda;dbg : Debuginfo.t;env : Backend_var.t option;poll : Lambda.poll_attribute;}type function_description = {fun_label : function_label;fun_arity : int;mutable fun_closed : bool;mutable fun_inline : (Backend_var.With_provenance.t list * ulambda) option;mutable fun_float_const_prop : bool;fun_poll : Lambda.poll_attribute;}type value_approximation = | Value_closure of function_description * value_approximation| Value_tuple of value_approximation array| Value_unknown| Value_const of uconstant| Value_global_field of string * intval compare_structured_constants :
+ ustructured_constant ->
+ ustructured_constant ->
+ inttype preallocated_block = {symbol : string;exported : bool;tag : int;fields : uconstant_block_field option list;provenance : usymbol_provenance option;}type preallocated_constant = {symbol : string;exported : bool;definition : ustructured_constant;provenance : usymbol_provenance option;}type with_constants =
+ ulambda * preallocated_block list * preallocated_constant listClambda_primitivestype mutable_flag = Asttypes.mutable_flagtype immediate_or_pointer = Lambda.immediate_or_pointertype initialization_or_assignment = Lambda.initialization_or_assignmenttype is_safe = Lambda.is_safetype primitive = | Pread_symbol of string| Pmakeblock of int * mutable_flag * block_shape| Pfield of int| Pfield_computed| Psetfield of int * immediate_or_pointer * initialization_or_assignment| Psetfield_computed of immediate_or_pointer * initialization_or_assignment| Pfloatfield of int| Psetfloatfield of int * initialization_or_assignment| Pduprecord of Types.record_representation * int| Pccall of Primitive.description| Praise of raise_kind| Psequand| Psequor| Pnot| Pnegint| Paddint| Psubint| Pmulint| Pdivint of is_safe| Pmodint of is_safe| Pandint| Porint| Pxorint| Plslint| Plsrint| Pasrint| Pintcomp of integer_comparison| Pcompare_ints| Pcompare_floats| Pcompare_bints of boxed_integer| Poffsetint of int| Poffsetref of int| Pintoffloat| Pfloatofint| Pnegfloat| Pabsfloat| Paddfloat| Psubfloat| Pmulfloat| Pdivfloat| Pfloatcomp of float_comparison| Pstringlength| Pstringrefu| Pstringrefs| Pbyteslength| Pbytesrefu| Pbytessetu| Pbytesrefs| Pbytessets| Pmakearray of array_kind * mutable_flagFor Pmakearray, the list of arguments must not be empty. The empty array should be represented by a distinguished constant in the middle end.
| Pduparray of array_kind * mutable_flagFor Pduparray, the argument must be an immutable array. The arguments of Pduparray give the kind and mutability of the array being *produced* by the duplication.
| Parraylength of array_kind| Parrayrefu of array_kind| Parraysetu of array_kind| Parrayrefs of array_kind| Parraysets of array_kind| Pisint| Pisout| Pbintofint of boxed_integer| Pintofbint of boxed_integer| Pcvtbint of boxed_integer * boxed_integer| Pnegbint of boxed_integer| Paddbint of boxed_integer| Psubbint of boxed_integer| Pmulbint of boxed_integer| Pdivbint of {size : boxed_integer;is_safe : is_safe;}| Pmodbint of {size : boxed_integer;is_safe : is_safe;}| Pandbint of boxed_integer| Porbint of boxed_integer| Pxorbint of boxed_integer| Plslbint of boxed_integer| Plsrbint of boxed_integer| Pasrbint of boxed_integer| Pbintcomp of boxed_integer * integer_comparison| Pbigarrayref of bool * int * bigarray_kind * bigarray_layout| Pbigarrayset of bool * int * bigarray_kind * bigarray_layout| Pbigarraydim of int| Pstring_load of memory_access_size * is_safe| Pbytes_load of memory_access_size * is_safe| Pbytes_set of memory_access_size * is_safe| Pbigstring_load of memory_access_size * is_safe| Pbigstring_set of memory_access_size * is_safe| Pbswap16| Pbbswap of boxed_integer| Pint_as_pointer| Popaqueand float_comparison = Lambda.float_comparison = and block_shape = Lambda.block_shapeand bigarray_kind = Lambda.bigarray_kind = and bigarray_layout = Lambda.bigarray_layout = Clflags.Compiler_passval of_string : string -> t optionval to_string : t -> stringval is_compilation_pass : t -> boolval available_pass_names : filter:(t -> bool) -> native:bool -> string listval can_save_ir_after : t -> boolval to_output_filename : t -> prefix:string -> stringval of_input_filename : string -> t optionClflags.Float_arg_helperOptimization parameters represented as floats indexed by round number.
val parse_no_error : string -> parsed ref -> parse_resultval get : key:int -> parsed -> floatClflags.Int_arg_helperOptimization parameters represented as ints indexed by round number.
val parse_no_error : string -> parsed ref -> parse_resultval get : key:int -> parsed -> intClflagsCommand line flags
module Int_arg_helper : sig ... endOptimization parameters represented as ints indexed by round number.
module Float_arg_helper : sig ... endOptimization parameters represented as floats indexed by round number.
type inlining_arguments = {inline_call_cost : int option;inline_alloc_cost : int option;inline_prim_cost : int option;inline_branch_cost : int option;inline_indirect_cost : int option;inline_lifting_benefit : int option;inline_branch_factor : float option;inline_max_depth : int option;inline_max_unroll : int option;inline_threshold : float option;inline_toplevel_threshold : int option;}val classic_arguments : inlining_argumentsval o1_arguments : inlining_argumentsval o2_arguments : inlining_argumentsval o3_arguments : inlining_argumentsval use_inlining_arguments_set : ?round:int -> inlining_arguments -> unitSet all the inlining arguments for a round. The default is set if no round is provided.
val objfiles : string list refval ccobjs : string list refval dllibs : string list refval compile_only : bool refval output_name : string option refval include_dirs : string list refval no_std_include : bool refval print_types : bool refval make_archive : bool refval debug : bool refval debug_full : bool refval unsafe : bool refval use_linscan : bool refval link_everything : bool refval custom_runtime : bool refval no_check_prims : bool refval bytecode_compatible_32 : bool refval output_c_object : bool refval output_complete_object : bool refval output_complete_executable : bool refval all_ccopts : string list refval classic : bool refval nopervasives : bool refval match_context_rows : int refval open_modules : string list refval preprocessor : string option refval all_ppx : string list refval absname : bool refval annotations : bool refval binary_annotations : bool refval use_threads : bool refval noassert : bool refval verbose : bool refval noprompt : bool refval nopromptcont : bool refval init_file : string option refval noinit : bool refval noversion : bool refval use_prims : string refval use_runtime : string refval plugin : bool refval principal : bool refval real_paths : bool refval recursive_types : bool refval strict_sequence : bool refval strict_formats : bool refval applicative_functors : bool refval make_runtime : bool refval c_compiler : string option refval no_auto_link : bool refval dllpaths : string list refval make_package : bool refval for_package : string option refval error_size : int refval float_const_prop : bool refval transparent_modules : bool refval unique_ids : bool refval locations : bool refval dump_source : bool refval dump_parsetree : bool refval dump_typedtree : bool refval dump_shape : bool refval dump_rawlambda : bool refval dump_lambda : bool refval dump_rawclambda : bool refval dump_clambda : bool refval dump_rawflambda : bool refval dump_flambda : bool refval dump_flambda_let : int option refval dump_instr : bool refval keep_camlprimc_file : bool refval keep_asm_file : bool refval optimize_for_speed : bool refval dump_cmm : bool refval dump_selection : bool refval dump_cse : bool refval dump_live : bool refval dump_spill : bool refval dump_split : bool refval dump_interf : bool refval dump_prefer : bool refval dump_regalloc : bool refval dump_reload : bool refval dump_scheduling : bool refval dump_linear : bool refval dump_interval : bool refval keep_startup_file : bool refval dump_combine : bool refval native_code : bool refval inline_threshold : Float_arg_helper.parsed refval inlining_report : bool refval simplify_rounds : int option refval default_simplify_rounds : int refval inline_max_unroll : Int_arg_helper.parsed refval inline_toplevel_threshold : Int_arg_helper.parsed refval inline_call_cost : Int_arg_helper.parsed refval inline_alloc_cost : Int_arg_helper.parsed refval inline_prim_cost : Int_arg_helper.parsed refval inline_branch_cost : Int_arg_helper.parsed refval inline_indirect_cost : Int_arg_helper.parsed refval inline_lifting_benefit : Int_arg_helper.parsed refval inline_branch_factor : Float_arg_helper.parsed refval dont_write_files : bool refval dlcode : bool refval pic_code : bool refval runtime_variant : string refval with_runtime : bool refval force_slash : bool refval keep_docs : bool refval keep_locs : bool refval unsafe_string : bool refval opaque : bool refval profile_columns : Profile.column list refval flambda_invariant_checks : bool refval unbox_closures : bool refval unbox_closures_factor : int refval unbox_free_vars_of_closures : bool refval unbox_specialised_args : bool refval clambda_checks : bool refval cmm_invariants : bool refval inline_max_depth : Int_arg_helper.parsed refval remove_unused_arguments : bool refval dump_flambda_verbose : bool refval classic_inlining : bool refval afl_instrument : bool refval afl_inst_ratio : int refval function_sections : bool refval all_passes : string list refval dump_into_file : bool refval dump_dir : string option refval color : Misc.Color.setting option refval color_reader : Misc.Color.setting env_readerval error_style : Misc.Error_style.setting option refval error_style_reader : Misc.Error_style.setting env_readerval unboxed_types : bool refval insn_sched : bool refmodule Compiler_pass : sig ... endval stop_after : Compiler_pass.t option refval should_stop_after : Compiler_pass.t -> boolval set_save_ir_after : Compiler_pass.t -> bool -> unitval should_save_ir_after : Compiler_pass.t -> boolval arg_spec : (string * Stdlib.Arg.spec * string) list refval add_arguments : string -> (string * Stdlib.Arg.spec * string) list -> unitClosureval intro :
+ backend:(module Backend_intf.S) ->
+ size:int ->
+ Lambda.lambda ->
+ Clambda.ulambdaClosure_conversionval lambda_to_flambda :
+ backend:(module Backend_intf.S) ->
+ module_ident:Ident.t ->
+ size:int ->
+ Lambda.lambda ->
+ Flambda.programGeneration of Flambda intermediate language code from Lambda code by performing a form of closure conversion.
Function declarations (which may bind one or more variables identifying functions, possibly with mutual recursion) are transformed to Set_of_closures expressions. Project_closure expressions are then used to select a closure for a particular function from a Set_of_closures expression. The Set_of_closures expressions say nothing about the actual runtime layout of the closures; this is handled when Flambda code is translated to Clambda code.
The following transformations are also performed during closure conversion:
Lambda.Const_block) are converted to applications of the Pmakeblock primitive.Levent debugging event nodes are removed and the information within them attached to function, method and raise calls.f is marked as a stub function *)Pdirapply and Prevapply application primitives are removed and converted to normal Flambda application nodes.The lambda_to_flambda function is not re-entrant.
Closure_conversion_aux.EnvUsed to remember which Variable.t values correspond to which Ident.t values during closure conversion, and similarly for static exception identifiers.
val empty : tval add_var : t -> Ident.t -> Variable.t -> tval add_vars : t -> Ident.t list -> Variable.t list -> tval find_var : t -> Ident.t -> Variable.tval find_var_exn : t -> Ident.t -> Variable.tval add_mutable_var : t -> Ident.t -> Mutable_variable.t -> tval find_mutable_var_exn : t -> Ident.t -> Mutable_variable.tval add_static_exception : t -> int -> Static_exception.t -> tval find_static_exception : t -> int -> Static_exception.tval at_toplevel : t -> boolFunction_decls.Function_declval create :
+ let_rec_ident:Ident.t option ->
+ closure_bound_var:Variable.t ->
+ kind:Lambda.function_kind ->
+ params:Ident.t list ->
+ body:Lambda.lambda ->
+ attr:Lambda.function_attribute ->
+ loc:Lambda.scoped_location ->
+ tval closure_bound_var : t -> Variable.tval kind : t -> Lambda.function_kindval body : t -> Lambda.lambdaval inline : t -> Lambda.inline_attributeval specialise : t -> Lambda.specialise_attributeval is_a_functor : t -> boolval stub : t -> boolval loc : t -> Lambda.scoped_locationval poll_attribute : t -> Lambda.poll_attributeval free_idents : t -> Ident.Set.tClosure_conversion_aux.Function_declsUsed to represent information about a set of function declarations during closure conversion. (The only case in which such a set may contain more than one declaration is when processing "let rec".)
module Function_decl : sig ... endval create : Function_decl.t list -> tval to_list : t -> Function_decl.t listval all_free_idents : t -> Ident.Set.tClosure_conversion_auxEnvironments and auxiliary structures used during closure conversion.
module Env : sig ... endUsed to remember which Variable.t values correspond to which Ident.t values during closure conversion, and similarly for static exception identifiers.
module Function_decls : sig ... endUsed to represent information about a set of function declarations during closure conversion. (The only case in which such a set may contain more than one declaration is when processing "let rec".)
Closure_element.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitClosure_element.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringClosure_element.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitClosure_element.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tClosure_elementinclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval wrap : Variable.t -> tval unwrap : t -> Variable.tval wrap_map : 'a Variable.Map.t -> 'a Map.tval unwrap_set : Set.t -> Variable.Set.tval in_compilation_unit : t -> Compilation_unit.t -> boolval get_compilation_unit : t -> Compilation_unit.tval unique_name : t -> stringval output_full : out_channel -> t -> unitClosure_id.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitClosure_id.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringClosure_id.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitClosure_id.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tClosure_idCR-someday lwhite: "Closure_id" is quite a generic name. I wonder whether something like "Closure_label" would better capture that it is the label of a projection.
An identifier, unique across the whole program (not just one compilation unit), that identifies a closure within a particular set of closures (viz. Project_closure).
include module type of Closure_elementinclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval wrap : Variable.t -> tval unwrap : t -> Variable.tval wrap_map : 'a Variable.Map.t -> 'a Map.tval unwrap_set : Set.t -> Variable.Set.tval in_compilation_unit : t -> Compilation_unit.t -> boolval get_compilation_unit : t -> Compilation_unit.tval unique_name : t -> stringval output_full : out_channel -> t -> unitClosure_middle_endval lambda_to_clambda :
+ backend:(module Backend_intf.S) ->
+ prefixname:string ->
+ ppf_dump:Stdlib.Format.formatter ->
+ Lambda.program ->
+ Clambda.with_constantsClosure_offsetsAssign numerical offsets, within closure blocks, for code pointers and environment entries.
type result = private {function_offsets : int Closure_id.Map.t;free_variable_offsets : int Var_within_closure.Map.t;}val compute : Flambda.program -> resultClosure_origin.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitClosure_origin.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringClosure_origin.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitClosure_origin.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tClosure_origininclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create : Closure_id.t -> tval get_compilation_unit : t -> Compilation_unit.tCmi_formattype cmi_infos = {cmi_name : Misc.modname;cmi_sign : Types.signature_item list;cmi_crcs : Misc.crcs;cmi_flags : pers_flags list;}val output_cmi : string -> out_channel -> cmi_infos -> Stdlib.Digest.tval input_cmi : in_channel -> cmi_infosval read_cmi : string -> cmi_infostype error = | Not_an_interface of Misc.filepath| Wrong_version_interface of Misc.filepath * string| Corrupted_interface of Misc.filepathexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitCmmtype machtype = machtype_component arrayval typ_void : machtypeval typ_val : machtypeval typ_addr : machtypeval typ_int : machtypeval typ_float : machtypeval lub_component :
+ machtype_component ->
+ machtype_component ->
+ machtype_componentLeast upper bound of two machtype_components.
val ge_component : machtype_component -> machtype_component -> boolReturns true iff the first supplied machtype_component is greater than or equal to the second under the relation used by lub_component.
val negate_integer_comparison : integer_comparison -> integer_comparisonval swap_integer_comparison : integer_comparison -> integer_comparisontype float_comparison = Lambda.float_comparison = val negate_float_comparison : float_comparison -> float_comparisonval swap_float_comparison : float_comparison -> float_comparisonval new_label : unit -> labelval set_label : label -> unitval cur_label : unit -> labeltype phantom_defining_expr = | Cphantom_const_int of Targetint.tThe phantom-let-bound variable is a constant integer. The argument must be the tagged representation of an integer within the range of type int on the target. (Analogously to Cconst_int.)
| Cphantom_const_symbol of stringThe phantom-let-bound variable is an alias for a symbol.
*)| Cphantom_var of Backend_var.tThe phantom-let-bound variable is an alias for another variable. The aliased variable must not be a bound by a phantom let.
*)| Cphantom_offset_var of {var : Backend_var.t;offset_in_words : int;}The phantom-let-bound-variable's value is defined by adding the given number of words to the pointer contained in the given identifier.
*)| Cphantom_read_field of {var : Backend_var.t;field : int;}The phantom-let-bound-variable's value is found by adding the given number of words to the pointer contained in the given identifier, then dereferencing.
*)| Cphantom_read_symbol_field of {}As for Uphantom_read_var_field, but with the pointer specified by a symbol.
| Cphantom_block of {tag : int;fields : Backend_var.t list;}The phantom-let-bound variable points at a block with the given structure.
*)and operation = | Capply of machtype| Cextcall of string * machtype * exttype list * boolThe machtype is the machine type of the result. The exttype list describes the unboxing types of the arguments. An empty list means "all arguments are machine words XInt".
| Cload of memory_chunk * Asttypes.mutable_flag| Calloc| Cstore of memory_chunk * Lambda.initialization_or_assignment| Caddi| Csubi| Cmuli| Cmulhi| Cdivi| Cmodi| Cand| Cor| Cxor| Clsl| Clsr| Casr| Ccmpi of integer_comparison| Caddv| Cadda| Ccmpa of integer_comparison| Cnegf| Cabsf| Caddf| Csubf| Cmulf| Cdivf| Cfloatofint| Cintoffloat| Ccmpf of float_comparison| Craise of Lambda.raise_kind| Ccheckbound| Copaqueand expression = | Cconst_int of int * Debuginfo.t| Cconst_natint of nativeint * Debuginfo.t| Cconst_float of float * Debuginfo.t| Cconst_symbol of string * Debuginfo.t| Cvar of Backend_var.t| Clet of Backend_var.With_provenance.t * expression * expression| Clet_mut of Backend_var.With_provenance.t * machtype * expression * expression| Cphantom_let of Backend_var.With_provenance.t
+ * phantom_defining_expr option
+ * expression| Cassign of Backend_var.t * expression| Ctuple of expression list| Cop of operation * expression list * Debuginfo.t| Csequence of expression * expression| Cifthenelse of expression
+ * Debuginfo.t
+ * expression
+ * Debuginfo.t
+ * expression
+ * Debuginfo.t| Cswitch of expression
+ * int array
+ * (expression * Debuginfo.t) array
+ * Debuginfo.t| Ccatch of rec_flag
+ * (int
+ * (Backend_var.With_provenance.t * machtype) list
+ * expression
+ * Debuginfo.t)
+ list
+ * expression| Cexit of int * expression list| Ctrywith of expression
+ * Backend_var.With_provenance.t
+ * expression
+ * Debuginfo.tEvery basic block should have a corresponding Debuginfo.t for its beginning.
type fundecl = {fun_name : string;fun_args : (Backend_var.With_provenance.t * machtype) list;fun_body : expression;fun_codegen_options : codegen_option list;fun_poll : Lambda.poll_attribute;fun_dbg : Debuginfo.t;}val ccatch :
+ (int
+ * (Backend_var.With_provenance.t * machtype) list
+ * expression
+ * expression
+ * Debuginfo.t) ->
+ expressionval iter_shallow_tail : (expression -> unit) -> expression -> boolEither apply the callback to all immediate sub-expressions that can produce the final result for the expression and return true, or do nothing and return false. Note that the notion of "tail" sub-expression used here does not match the one used to trigger tail calls; in particular, try...with handlers are considered to be in tail position (because their result become the final result for the expression).
val map_tail : (expression -> expression) -> expression -> expressionApply the transformation to an expression, trying to push it to all inner sub-expressions that can produce the final result. Same disclaimer as for iter_shallow_tail about the notion of "tail" sub-expression.
val map_shallow : (expression -> expression) -> expression -> expressionApply the transformation to each immediate sub-expression.
Cmm_helpersval bind :
+ string ->
+ Cmm.expression ->
+ (Cmm.expression -> Cmm.expression) ->
+ Cmm.expressionbind name arg fn is equivalent to let name = arg in fn name, or simply fn arg if arg is simple enough
val bind_load :
+ string ->
+ Cmm.expression ->
+ (Cmm.expression -> Cmm.expression) ->
+ Cmm.expressionSame as bind, but also treats loads from a variable as simple
val bind_nonvar :
+ string ->
+ Cmm.expression ->
+ (Cmm.expression -> Cmm.expression) ->
+ Cmm.expressionSame as bind, but does not treat variables as simple
Headers
val floatarray_tag : Debuginfo.t -> Cmm.expressionA constant equal to the tag for float arrays
block_header tag size creates a header with tag tag for a block of size size
Closure info for a closure of given arity and distance to environment
val alloc_float_header : Debuginfo.t -> Cmm.expressionWrappers
val alloc_floatarray_header : int -> Debuginfo.t -> Cmm.expressionval alloc_closure_header : int -> Debuginfo.t -> Cmm.expressionval alloc_infix_header : int -> Debuginfo.t -> Cmm.expressionval alloc_closure_info :
+ arity:int ->
+ startenv:int ->
+ Debuginfo.t ->
+ Cmm.expressionval alloc_boxedint32_header : Debuginfo.t -> Cmm.expressionval alloc_boxedint64_header : Debuginfo.t -> Cmm.expressionval alloc_boxedintnat_header : Debuginfo.t -> Cmm.expressionIntegers
Minimal/maximal OCaml integer values whose backend representation fits in a regular OCaml integer
val int_const : Debuginfo.t -> int -> Cmm.expressionMake an integer constant from the given integer (tags the integer)
val cint_const : int -> Cmm.data_itemval targetint_const : int -> Targetint.tval natint_const_untagged : Debuginfo.t -> Stdlib.Nativeint.t -> Cmm.expressionMake a Cmm constant holding the given nativeint value. Uses Cconst_int instead of Cconst_nativeint when possible to preserve peephole optimisations.
val add_const : Cmm.expression -> int -> Debuginfo.t -> Cmm.expressionAdd an integer to the given expression
val incr_int : Cmm.expression -> Debuginfo.t -> Cmm.expressionIncrement/decrement of integers
val decr_int : Cmm.expression -> Debuginfo.t -> Cmm.expressionval ignore_low_bit_int : Cmm.expression -> Cmm.expressionSimplify the given expression knowing its last bit will be irrelevant
val ignore_high_bit_int : Cmm.expression -> Cmm.expressionSimplify the given expression knowing its first bit will be irrelevant
val add_int : Cmm.expression -> Cmm.expression -> Debuginfo.t -> Cmm.expressionArithmetical operations on integers
val sub_int : Cmm.expression -> Cmm.expression -> Debuginfo.t -> Cmm.expressionval lsl_int : Cmm.expression -> Cmm.expression -> Debuginfo.t -> Cmm.expressionval mul_int : Cmm.expression -> Cmm.expression -> Debuginfo.t -> Cmm.expressionval lsr_int : Cmm.expression -> Cmm.expression -> Debuginfo.t -> Cmm.expressionval asr_int : Cmm.expression -> Cmm.expression -> Debuginfo.t -> Cmm.expressionval div_int :
+ Cmm.expression ->
+ Cmm.expression ->
+ Lambda.is_safe ->
+ Debuginfo.t ->
+ Cmm.expressionval mod_int :
+ Cmm.expression ->
+ Cmm.expression ->
+ Lambda.is_safe ->
+ Debuginfo.t ->
+ Cmm.expressionval tag_int : Cmm.expression -> Debuginfo.t -> Cmm.expressionInteger tagging. tag_int x = (x lsl 1) + 1
val untag_int : Cmm.expression -> Debuginfo.t -> Cmm.expressionInteger untagging. untag_int x = (x asr 1)
val safe_div_bi :
+ Lambda.is_safe ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Primitive.boxed_integer ->
+ Debuginfo.t ->
+ Cmm.expressionSpecific division operations for boxed integers
val safe_mod_bi :
+ Lambda.is_safe ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Primitive.boxed_integer ->
+ Debuginfo.t ->
+ Cmm.expressionval mk_if_then_else :
+ Debuginfo.t ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expressionIf-Then-Else expression mk_if_then_else dbg cond ifso_dbg ifso ifnot_dbg ifnot associates dbg to the global if-then-else expression, ifso_dbg to the then branch ifso, and ifnot_dbg to the else branch ifnot
val mk_not : Debuginfo.t -> Cmm.expression -> Cmm.expressionBoolean negation
val mk_compare_ints :
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expressionInteger and float comparison that returns int not bool
val mk_compare_floats :
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expressionval create_loop : Cmm.expression -> Debuginfo.t -> Cmm.expressionLoop construction (while true do expr done). Used to be represented as Cloop.
val raise_symbol : Debuginfo.t -> string -> Cmm.expressionException raising
val test_bool : Debuginfo.t -> Cmm.expression -> Cmm.expressionConvert a tagged integer into a raw integer with boolean meaning
val box_float : Debuginfo.t -> Cmm.expression -> Cmm.expressionFloat boxing and unboxing
val unbox_float : Debuginfo.t -> Cmm.expression -> Cmm.expressionval box_complex :
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expressionComplex number creation and access
val complex_re : Cmm.expression -> Debuginfo.t -> Cmm.expressionval complex_im : Cmm.expression -> Debuginfo.t -> Cmm.expressionval return_unit : Debuginfo.t -> Cmm.expression -> Cmm.expressionMake the given expression return a unit value
val remove_unit : Cmm.expression -> Cmm.expressionRemove a trailing unit return if any
Blocks
val field_address : Cmm.expression -> int -> Debuginfo.t -> Cmm.expressionfield_address ptr n dbg returns an expression for the address of the nth field of the block pointed to by ptr
val get_field_gen :
+ Asttypes.mutable_flag ->
+ Cmm.expression ->
+ int ->
+ Debuginfo.t ->
+ Cmm.expressionget_field_gen mut ptr n dbg returns an expression for the access to the nth field of the block pointed to by ptr
val set_field :
+ Cmm.expression ->
+ int ->
+ Cmm.expression ->
+ Lambda.initialization_or_assignment ->
+ Debuginfo.t ->
+ Cmm.expressionset_field ptr n newval init dbg returns an expression for setting the nth field of the block pointed to by ptr to newval
val get_header : Cmm.expression -> Debuginfo.t -> Cmm.expressionLoad a block's header
val get_header_without_profinfo :
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionSame as get_header, but also set all profiling bits of the header are to 0 (if profiling is enabled)
val get_tag : Cmm.expression -> Debuginfo.t -> Cmm.expressionLoad a block's tag
val get_size : Cmm.expression -> Debuginfo.t -> Cmm.expressionLoad a block's size
Arrays
val is_addr_array_hdr : Cmm.expression -> Debuginfo.t -> Cmm.expressionCheck whether the given array is an array of regular OCaml values (as opposed to unboxed floats), from its header or pointer
val is_addr_array_ptr : Cmm.expression -> Debuginfo.t -> Cmm.expressionval addr_array_length_shifted : Cmm.expression -> Debuginfo.t -> Cmm.expressionGet the length of an array from its header Shifts by one bit less than necessary, keeping one of the GC colour bits, to save an operation when returning the length as a caml integer or when comparing it to a caml integer. Assumes the header does not have any profiling info (as returned by get_header_without_profinfo)
val float_array_length_shifted :
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval array_indexing :
+ ?typ:Cmm.machtype_component ->
+ int ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionFor array_indexing ?typ log2size ptr ofs dbg : Produces a pointer to the element of the array ptr on the position ofs with the given element log2size log2 element size. ofs is given as a tagged int expression. The optional ?typ argument is the C-- type of the result. By default, it is Addr, meaning we are constructing a derived pointer into the heap. If we know the pointer is outside the heap (this is the case for bigarray indexing), we give type Int instead.
val addr_array_ref :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionArray loads and stores unboxed_float_array_ref and float_array_ref differ in the boxing of the result; float_array_set takes an unboxed float
val int_array_ref :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval unboxed_float_array_ref :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval float_array_ref :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval addr_array_set :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval addr_array_initialize :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval int_array_set :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval float_array_set :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionStrings
val string_length : Cmm.expression -> Debuginfo.t -> Cmm.expressionval bigstring_length : Cmm.expression -> Debuginfo.t -> Cmm.expressionObjects
val lookup_tag :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionLookup a method by its hash, using caml_get_public_method Arguments :
val lookup_label :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionLookup a method by its offset in the method table Arguments :
val call_cached_method :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression list ->
+ Debuginfo.t ->
+ Cmm.expressionLookup and call a method using the method cache Arguments :
Allocations
val make_alloc : Debuginfo.t -> int -> Cmm.expression list -> Cmm.expressionAllocate a block of regular values with the given tag
val make_float_alloc :
+ Debuginfo.t ->
+ int ->
+ Cmm.expression list ->
+ Cmm.expressionAllocate a block of unboxed floats with the given tag
Bounds checking
val make_checkbound : Debuginfo.t -> Cmm.expression list -> Cmm.expressionGenerate a Ccheckbound term
val check_bound :
+ Lambda.is_safe ->
+ Clambda_primitives.memory_access_size ->
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expressioncheck_bound safety access_size dbg length a2 k prefixes expression k with a check that reading access_size bits starting at position a2 in a string/bytes value of length length is within bounds, unless safety is Unsafe.
val opaque : Cmm.expression -> Debuginfo.t -> Cmm.expressionSys.opaque_identity
Generic application functions
Get the symbol for the generic application with n arguments, and ensure its presence in the set of defined symbols
If n is positive, get the symbol for the generic currying wrapper with n arguments, and ensure its presence in the set of defined symbols. Otherwise, do the same for the generic tuple wrapper with -n arguments.
Bigarrays
val bigarray_get :
+ bool ->
+ Lambda.bigarray_kind ->
+ Lambda.bigarray_layout ->
+ Cmm.expression ->
+ Cmm.expression list ->
+ Debuginfo.t ->
+ Cmm.expressionbigarray_get unsafe kind layout b args dbg
Lambda.bigarray_kindLambda.bigarray_layoutval bigarray_set :
+ bool ->
+ Lambda.bigarray_kind ->
+ Lambda.bigarray_layout ->
+ Cmm.expression ->
+ Cmm.expression list ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionbigarray_set unsafe kind layout b args newval dbg Same as bigarray_get, with newval the value being assigned
Operations on 32-bit integers
val low_32 : Debuginfo.t -> Cmm.expression -> Cmm.expressionlow_32 _ x is a value which agrees with x on at least the low 32 bits
val sign_extend_32 : Debuginfo.t -> Cmm.expression -> Cmm.expressionSign extend from 32 bits to the word size
val zero_extend_32 : Debuginfo.t -> Cmm.expression -> Cmm.expressionZero extend from 32 bits to the word size
Boxed numbers
val box_int_gen :
+ Debuginfo.t ->
+ Primitive.boxed_integer ->
+ Cmm.expression ->
+ Cmm.expressionBox a given integer, without sharing of constants
val unbox_int :
+ Debuginfo.t ->
+ Primitive.boxed_integer ->
+ Cmm.expression ->
+ Cmm.expressionUnbox a given boxed integer
val make_unsigned_int :
+ Primitive.boxed_integer ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionUsed to prepare 32-bit integers on 64-bit platforms for a lsr operation
val unaligned_load_16 :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval unaligned_set_16 :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval unaligned_load_32 :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval unaligned_set_32 :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval unaligned_load_64 :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval unaligned_set_64 :
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionRaw memory accesses
val unaligned_set :
+ Clambda_primitives.memory_access_size ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionunaligned_set size ptr idx newval dbg
val unaligned_load :
+ Clambda_primitives.memory_access_size ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionunaligned_load size ptr idx dbg
val box_sized :
+ Clambda_primitives.memory_access_size ->
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expressionbox_sized size dbg exp
Primitives
val simplif_primitive :
+ Clambda_primitives.primitive ->
+ Clambda_primitives.primitivetype unary_primitive = Cmm.expression -> Debuginfo.t -> Cmm.expressionval floatfield : int -> unary_primitiveReturn the n-th field of a float array (or float-only record), as an unboxed float
val int_as_pointer : unary_primitiveInt_as_pointer primitive
val raise_prim : Lambda.raise_kind -> unary_primitiveRaise primitive
val negint : unary_primitiveUnary negation of an OCaml integer
val offsetint : int -> unary_primitiveAdd a constant number to an OCaml integer
val offsetref : int -> unary_primitiveAdd a constant number to an OCaml integer reference
val arraylength : Lambda.array_kind -> unary_primitiveReturn the length of the array argument, as an OCaml integer
val bbswap : Primitive.boxed_integer -> unary_primitiveByte swap primitive Operates on Cmm integers (unboxed values)
val bswap16 : unary_primitive16-bit byte swap primitive Operates on Cmm integers (untagged integers)
type binary_primitive =
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval setfield :
+ int ->
+ Lambda.immediate_or_pointer ->
+ Lambda.initialization_or_assignment ->
+ binary_primitivesetfield offset value_is_ptr init ptr value dbg
val setfloatfield :
+ int ->
+ Lambda.initialization_or_assignment ->
+ binary_primitivesetfloatfield offset init ptr value dbg value is expected to be an unboxed floating point number
val add_int_caml : binary_primitiveOperations on OCaml integers
val sub_int_caml : binary_primitiveval mul_int_caml : binary_primitiveval div_int_caml : Lambda.is_safe -> binary_primitiveval mod_int_caml : Lambda.is_safe -> binary_primitiveval and_int_caml : binary_primitiveval or_int_caml : binary_primitiveval xor_int_caml : binary_primitiveval lsl_int_caml : binary_primitiveval lsr_int_caml : binary_primitiveval asr_int_caml : binary_primitiveval int_comp_caml : Lambda.integer_comparison -> binary_primitiveStrings, Bytes and Bigstrings
val stringref_unsafe : binary_primitiveRegular string/bytes access. Args: string/bytes, index
val stringref_safe : binary_primitiveval string_load :
+ Clambda_primitives.memory_access_size ->
+ Lambda.is_safe ->
+ binary_primitiveLoad by chunk from string/bytes, bigstring. Args: string, index
val bigstring_load :
+ Clambda_primitives.memory_access_size ->
+ Lambda.is_safe ->
+ binary_primitiveArrays
val arrayref_unsafe : Lambda.array_kind -> binary_primitiveArray access. Args: array, index
val arrayref_safe : Lambda.array_kind -> binary_primitivetype ternary_primitive =
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressionval setfield_computed :
+ Lambda.immediate_or_pointer ->
+ Lambda.initialization_or_assignment ->
+ ternary_primitiveSame as setfield, except the offset is one of the arguments. Args: pointer (structure/array/...), index, value
val bytesset_unsafe : ternary_primitiveSet the byte at the given offset to the given value. Args: bytes, index, value
val bytesset_safe : ternary_primitiveval arrayset_unsafe : Lambda.array_kind -> ternary_primitiveSet the element at the given index in the given array to the given value. WARNING: if kind is Pfloatarray, then value is expected to be an _unboxed_ float. Otherwise, it is expected to be a regular caml value, including in the case where the array contains floats. Args: array, index, value
val arrayset_safe : Lambda.array_kind -> ternary_primitiveval bytes_set :
+ Clambda_primitives.memory_access_size ->
+ Lambda.is_safe ->
+ ternary_primitiveSet a chunk of data in the given bytes or bigstring structure. See also string_load and bigstring_load. Note: value is expected to be an unboxed number of the given size. Args: pointer, index, value
val bigstring_set :
+ Clambda_primitives.memory_access_size ->
+ Lambda.is_safe ->
+ ternary_primitiveSwitch
val transl_isout :
+ Cmm.expression ->
+ Cmm.expression ->
+ Debuginfo.t ->
+ Cmm.expressiontransl_isout h arg dbg
val make_switch :
+ Cmm.expression ->
+ int array ->
+ (Cmm.expression * Debuginfo.t) array ->
+ Debuginfo.t ->
+ Cmm.expressionmake_switch arg cases actions dbg : Generate a Cswitch construct, or optimize as a static table lookup when possible.
val transl_int_switch :
+ Debuginfo.t ->
+ Cmm.expression ->
+ int ->
+ int ->
+ (int * Cmm.expression) list ->
+ Cmm.expression ->
+ Cmm.expressiontransl_int_switch loc arg low high cases default
val transl_switch_clambda :
+ Debuginfo.t ->
+ Cmm.expression ->
+ int array ->
+ Cmm.expression array ->
+ Cmm.expressiontransl_switch_clambda loc arg index cases
val strmatch_compile :
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expression option ->
+ (string * Cmm.expression) list ->
+ Cmm.expressionstrmatch_compile dbg arg default cases
Closures and function applications
val ptr_offset : Cmm.expression -> int -> Debuginfo.t -> Cmm.expressionAdds a constant offset to a pointer (for infix access)
val direct_apply :
+ string ->
+ Cmm.expression list ->
+ Debuginfo.t ->
+ Cmm.expressionDirect application of a function via a symbol
val generic_apply :
+ Asttypes.mutable_flag ->
+ Cmm.expression ->
+ Cmm.expression list ->
+ Debuginfo.t ->
+ Cmm.expressionGeneric application of a function to one or several arguments. The mutable_flag argument annotates the loading of the code pointer from the closure. The Cmmgen code uses a mutable load by default, with a special case when the load is from (the first function of) the currently defined closure.
val send :
+ Lambda.meth_kind ->
+ Cmm.expression ->
+ Cmm.expression ->
+ Cmm.expression list ->
+ Debuginfo.t ->
+ Cmm.expressionMethod call : send kind met obj args dbg
met is a method identifier, which can be a hashed variant or an index in obj's method table, depending on kindobj is the object whose method is being calledargs is the extra arguments to the method call (Note: I'm not aware of any way for the frontend to generate any arguments other than the cache and cache position)Generic Cmm fragments
val generic_functions : bool -> Cmx_format.unit_infos list -> Cmm.phrase listGenerate generic functions
val placeholder_dbg : unit -> Debuginfo.tval placeholder_fun_dbg : human_name:string -> Debuginfo.tval entry_point : string list -> Cmm.phraseEntry point
val global_table : string list -> Cmm.phraseGenerate the caml_globals table
val reference_symbols : string list -> Cmm.phraseAdd references to the given symbols
val globals_map :
+ (string * Stdlib.Digest.t option * Stdlib.Digest.t option * string list) list ->
+ Cmm.phraseGenerate the caml_globals_map structure, as a marshalled string constant
val frame_table : string list -> Cmm.phraseGenerate the caml_frametable table, referencing the frametables from the given compilation units
val data_segment_table : string list -> Cmm.phraseGenerate the tables for data and code positions respectively of the given compilation units
val code_segment_table : string list -> Cmm.phraseval predef_exception : int -> string -> Cmm.phraseGenerate data for a predefined exception
val plugin_header :
+ (Cmx_format.unit_infos * Stdlib.Digest.t) list ->
+ Cmm.phraseEmit constant symbols
val cdefine_symbol : (string * Cmmgen_state.is_global) -> Cmm.data_item listProduce the data_item list corresponding to a symbol definition
val emit_block :
+ (string * Cmmgen_state.is_global) ->
+ nativeint ->
+ Cmm.data_item list ->
+ Cmm.data_item listemit_block symb white_header cont prepends to cont the header and symbol for the block. cont must already contain the fields of the block (and may contain additional data items afterwards).
val emit_float_constant :
+ (string * Cmmgen_state.is_global) ->
+ float ->
+ Cmm.data_item list ->
+ Cmm.data_item listEmit specific kinds of constant blocks as data items
val emit_string_constant :
+ (string * Cmmgen_state.is_global) ->
+ string ->
+ Cmm.data_item list ->
+ Cmm.data_item listval emit_int32_constant :
+ (string * Cmmgen_state.is_global) ->
+ int32 ->
+ Cmm.data_item list ->
+ Cmm.data_item listval emit_int64_constant :
+ (string * Cmmgen_state.is_global) ->
+ int64 ->
+ Cmm.data_item list ->
+ Cmm.data_item listval emit_nativeint_constant :
+ (string * Cmmgen_state.is_global) ->
+ nativeint ->
+ Cmm.data_item list ->
+ Cmm.data_item listval emit_float_array_constant :
+ (string * Cmmgen_state.is_global) ->
+ float list ->
+ Cmm.data_item list ->
+ Cmm.data_item listval fundecls_size : Clambda.ufunction list -> intval emit_constant_closure :
+ (string * Cmmgen_state.is_global) ->
+ Clambda.ufunction list ->
+ Cmm.data_item list ->
+ Cmm.data_item list ->
+ Cmm.data_item listval emit_preallocated_blocks :
+ Clambda.preallocated_block list ->
+ Cmm.phrase list ->
+ Cmm.phrase listCmm_invariantsrun ppf fundecl analyses the given function, and returns whether any errors were encountered (with corresponding error messages printed on the given formatter).
val run : Stdlib.Format.formatter -> Cmm.fundecl -> boolCmmgenval compunit :
+ (Clambda.ulambda
+ * Clambda.preallocated_block list
+ * Clambda.preallocated_constant list) ->
+ Cmm.phrase listCmmgen_stateMutable state used by Cmmgen.
type constant = | Const_closure of is_global * Clambda.ufunction list * Clambda.uconstant list| Const_table of is_global * Cmm.data_item listval add_constant : Misc.Stdlib.String.t -> constant -> unitval add_data_items : Cmm.data_item list -> unitval add_function : Clambda.ufunction -> unitval get_and_clear_constants : unit -> constant Misc.Stdlib.String.Map.tval get_and_clear_data_items : unit -> Cmm.data_item listval next_function : unit -> Clambda.ufunction optionval set_structured_constants : Clambda.preallocated_constant list -> unitval add_structured_constant : string -> Clambda.ustructured_constant -> unitval structured_constant_of_sym : string -> Clambda.ustructured_constant optionCmo_formattype reloc_info = | Reloc_literal of Lambda.structured_constant| Reloc_getglobal of Ident.t| Reloc_setglobal of Ident.t| Reloc_primitive of stringtype compilation_unit = {cu_name : Misc.modname;mutable cu_pos : int;cu_codesize : int;cu_reloc : (reloc_info * int) list;cu_imports : Misc.crcs;cu_required_globals : Ident.t list;cu_primitives : string list;mutable cu_force_link : bool;mutable cu_debug : int;cu_debugsize : int;}type library = {lib_units : compilation_unit list;lib_custom : bool;lib_ccobjs : string list;lib_ccopts : string list;lib_dllibs : string list;}Cmt2annotval variables_iterator : Location.t -> Tast_iterator.iteratorval bind_variables : Location.t -> 'a Typedtree.general_pattern -> unitval bind_bindings : Location.t -> Typedtree.value_binding list -> unitval bind_cases : 'a Typedtree.case list -> unitval record_module_binding : Location.t -> Typedtree.module_binding -> unitval iterator : scope:Location.t -> bool -> Tast_iterator.iteratorval binary_part : Tast_iterator.iterator -> Cmt_format.binary_part -> unitval gen_annot :
+ string option ->
+ sourcefile:string option ->
+ use_summaries:bool ->
+ Cmt_format.binary_annots ->
+ unitCmt_formatcmt and cmti files format.
The layout of a cmt file is as follows: <cmt> := {<cmi>} <cmt magic> {cmt infos} {<source info>} where <cmi> is the cmi file format: <cmi> := <cmi magic> <cmi info>. More precisely, the optional <cmi> part must be present if and only if the file is:
Thus, we provide a common reading function for cmi and cmt(i) files which returns an option for each of the three parts: cmi info, cmt info, source info.
type binary_annots = | Packed of Types.signature * string list| Implementation of Typedtree.structure| Interface of Typedtree.signature| Partial_implementation of binary_part array| Partial_interface of binary_part arrayand binary_part = | Partial_structure of Typedtree.structure| Partial_structure_item of Typedtree.structure_item| Partial_expression of Typedtree.expression| Partial_pattern : 'k Typedtree.pattern_category
+ * 'k Typedtree.general_pattern -> binary_part| Partial_class_expr of Typedtree.class_expr| Partial_signature of Typedtree.signature| Partial_signature_item of Typedtree.signature_item| Partial_module_type of Typedtree.module_typetype cmt_infos = {cmt_modname : Misc.modname;cmt_annots : binary_annots;cmt_value_dependencies : (Types.value_description * Types.value_description)
+ list;cmt_comments : (string * Location.t) list;cmt_args : string array;cmt_sourcefile : string option;cmt_builddir : string;cmt_loadpath : string list;cmt_source_digest : string option;cmt_initial_env : Env.t;cmt_imports : Misc.crcs;cmt_interface_digest : Stdlib.Digest.t option;cmt_use_summaries : bool;cmt_uid_to_loc : Location.t Shape.Uid.Tbl.t;cmt_impl_shape : Shape.t option;}exception Error of errorval read : string -> Cmi_format.cmi_infos option * cmt_infos optionread filename opens filename, and extract both the cmi_infos, if it exists, and the cmt_infos, if it exists. Thus, it can be used with .cmi, .cmt and .cmti files.
.cmti files always contain a cmi_infos at the beginning. .cmt files only contain a cmi_infos at the beginning if there is no associated .cmti file.
val read_cmt : string -> cmt_infosval read_cmi : string -> Cmi_format.cmi_infosval save_cmt :
+ string ->
+ string ->
+ binary_annots ->
+ string option ->
+ Env.t ->
+ Cmi_format.cmi_infos option ->
+ Shape.t option ->
+ unitsave_cmt filename modname binary_annots sourcefile initial_env cmi writes a cmt(i) file.
val read_magic_number : in_channel -> stringval add_saved_type : binary_part -> unitval get_saved_types : unit -> binary_part listval set_saved_types : binary_part list -> unitval record_value_dependency :
+ Types.value_description ->
+ Types.value_description ->
+ unitCmx_formattype unit_infos = {mutable ui_name : Misc.modname;mutable ui_symbol : string;mutable ui_defines : string list;mutable ui_imports_cmi : Misc.crcs;mutable ui_imports_cmx : Misc.crcs;mutable ui_curry_fun : int list;mutable ui_apply_fun : int list;mutable ui_send_fun : int list;mutable ui_export_info : export_info;mutable ui_force_link : bool;}type library_infos = {lib_units : (unit_infos * Stdlib.Digest.t) list;lib_ccobjs : string list;lib_ccopts : string list;}Cmxs_formattype dynunit = {dynu_name : Misc.modname;dynu_crc : Stdlib.Digest.t;dynu_imports_cmi : Misc.crcs;dynu_imports_cmx : Misc.crcs;dynu_defines : string list;}ColoringComballocval fundecl : Mach.fundecl -> Mach.fundeclCompenvval first_ccopts : string list refval first_ppx : string list refval first_include_dirs : string list refval last_include_dirs : string list refval last_objfiles : string list refval first_objfiles : string list refval stop_early : bool refval has_linker_inputs : bool refval readenv : Stdlib.Format.formatter -> readenv_position -> unitval defer : deferred_action -> unitval process_deferred_actions :
+ (Stdlib.Format.formatter
+ * (start_from:Clflags.Compiler_pass.t ->
+ source_file:string ->
+ output_prefix:string ->
+ unit)
+ * (source_file:string ->
+ output_prefix:string ->
+ unit)
+ * string
+ * string) ->
+ unitval parse_arguments :
+ ?current:int ref ->
+ string array ref ->
+ Stdlib.Arg.anon_fun ->
+ string ->
+ unitCompilation_unit.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitCompilation_unit.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringCompilation_unit.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitCompilation_unit.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tCompilation_unitinclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create : Ident.t -> Linkage_name.t -> tval get_linkage_name : t -> Linkage_name.tval is_current : t -> boolval set_current : t -> unitval get_current : unit -> t optionval get_current_exn : unit -> tval get_current_id_exn : unit -> Ident.tval string_for_printing : t -> stringCompileBytecode compilation for .ml and .mli files.
val implementation :
+ start_from:Clflags.Compiler_pass.t ->
+ source_file:string ->
+ output_prefix:string ->
+ unit*
val to_bytecode :
+ Compile_common.info ->
+ Typedtree.implementation ->
+ Instruct.instruction list * Ident.Set.tto_bytecode info typed takes a typechecked implementation and returns its bytecode.
val emit_bytecode :
+ Compile_common.info ->
+ (Instruct.instruction list * Ident.Set.t) ->
+ unitemit_bytecode bytecode output the bytecode executable.
Compile_commonCommon compilation pipeline between bytecode and native.
type info = {source_file : string;module_name : string;output_prefix : string;env : Env.t;ppf_dump : Stdlib.Format.formatter;tool_name : string;native : bool;}Information needed to compile a file.
val with_info :
+ native:bool ->
+ tool_name:string ->
+ source_file:string ->
+ output_prefix:string ->
+ dump_ext:string ->
+ (info -> 'a) ->
+ 'awith_info ~native ~tool_name ~source_file ~output_prefix ~dump_ext k invokes its continuation k with an info structure built from its input, after initializing various global variables. This info structure and the initialized global state are not valid anymore after the continuation returns.
Due to current implementation limitations in the compiler, it is unsafe to try to compile several distinct compilation units by calling with_info several times.
val parse_intf : info -> Parsetree.signatureparse_intf info parses an interface (usually an .mli file).
val typecheck_intf : info -> Parsetree.signature -> Typedtree.signaturetypecheck_intf info parsetree typechecks an interface and returns the typedtree of the associated signature.
val emit_signature : info -> Parsetree.signature -> Typedtree.signature -> unitemit_signature info parsetree typedtree emits the .cmi file containing the given signature.
val interface : info -> unitThe complete compilation pipeline for interfaces.
val parse_impl : info -> Parsetree.structureparse_impl info parses an implementation (usually an .ml file).
val typecheck_impl : info -> Parsetree.structure -> Typedtree.implementationtypecheck_impl info parsetree typechecks an implementation and returns the typedtree of the associated module, its public interface, and a coercion against that public interface.
val implementation :
+ info ->
+ backend:(info -> Typedtree.implementation -> unit) ->
+ unitThe complete compilation pipeline for implementations.
val cmo : info -> stringval cmx : info -> stringval obj : info -> stringval annot : info -> stringReturn the filename of some compiler build artifacts associated with the file being compiled.
Compilenvval imported_sets_of_closures_table :
+ Simple_value_approx.function_declarations option Set_of_closures_id.Tbl.tval unit_id_from_name : string -> Ident.tval current_unit_infos : unit -> Cmx_format.unit_infosval current_unit_linkage_name : unit -> Linkage_name.tval current_unit : unit -> Compilation_unit.tval current_unit_symbol : unit -> Symbol.tval is_predefined_exception : Symbol.t -> boolval unit_for_global : Ident.t -> Compilation_unit.tval symbol_for_global : Ident.t -> stringval global_approx : Ident.t -> Clambda.value_approximationval set_global_approx : Clambda.value_approximation -> unitval set_export_info : Export_info.t -> unitval approx_env : unit -> Export_info.tval approx_for_global : Compilation_unit.t -> Export_info.t optionval closure_symbol : Closure_id.t -> Symbol.tval function_label : Closure_id.t -> stringval new_structured_constant :
+ Clambda.ustructured_constant ->
+ shared:bool ->
+ stringval structured_constants : unit -> Clambda.preallocated_constant listval structured_constant_of_symbol :
+ string ->
+ Clambda.ustructured_constant optionval snapshot : unit -> structured_constantsval backtrack : structured_constants -> unitval read_unit_info : string -> Cmx_format.unit_infos * Stdlib.Digest.tval write_unit_info : Cmx_format.unit_infos -> string -> unitval cache_unit_info : Cmx_format.unit_infos -> unitval require_global : Ident.t -> unitval read_library_info : string -> Cmx_format.library_infosexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitCompmiscval initial_env : unit -> Env.tval set_from_env : 'a option ref -> 'a Clflags.env_reader -> unitval with_ppf_dump : file_prefix:string -> (Stdlib.Format.formatter -> 'a) -> 'aConditionCondition variables to synchronize between threads.
Condition variables are used when one thread wants to wait until another thread has finished doing something: the former thread 'waits' on the condition variable, the latter thread 'signals' the condition when it is done. Condition variables should always be protected by a mutex. The typical use is (if D is a shared data structure, m its mutex, and c is a condition variable):
Mutex.lock m;
+while (* some predicate P over D is not satisfied *) do
+ Condition.wait c m
+done;
+(* Modify D *)
+if (* the predicate P over D is now satisfied *) then Condition.signal c;
+Mutex.unlock mval create : unit -> tReturn a new condition variable.
wait c m atomically unlocks the mutex m and suspends the calling process on the condition variable c. The process will restart after the condition variable c has been signalled. The mutex m is locked again before wait returns.
val signal : t -> unitsignal c restarts one of the processes waiting on the condition variable c.
val broadcast : t -> unitbroadcast c restarts all processes waiting on the condition variable c.
ConfigSystem configuration
Warning: this module is unstable and part of compiler-libs.
The "kind" of the C compiler, assembler and linker used: one of "cc" (for Unix-style C compilers) "msvc" (for Microsoft Visual C++ and MASM)
The linker to use for packaging (ocamlopt -pack) and for partial links (ocamlopt -output-obj).
Option to add a directory to be searched for libraries at runtime (used by ocamlmklib)
Option to add a directory to be searched for shared libraries at runtime (used by ocamlmklib)
val interface_suffix : string refSuffix for interface file names
Normally the same as Obj.lazy_tag. Separate definition because of technical reasons for bootstrapping.
Size in words of safe area at bottom of VM stack, see runtime/caml/config.h
Size in words of the safety margin between the bottom of the stack and the stack pointer. This margin can be used by intermediate computations of some instructions, or the event handler.
Name of executable produced by linking if none is given with -o, e.g. a.out under Unix.
Whether the compiler was configured with -force-safe-string; in that case, the -unsafe-string compile-time option is unavailable
Whether the compiler was configured to use the -safe-string or -unsafe-string compile-time option by default.
Whether the compiler was configured to generate each function in a separate section
Whether shared libraries are supported
val print_config : out_channel -> unitAccess to configuration values
Module_name.Maptype key = tThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Module_name.Settype elt = tThe type of the set elements.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Module_name.Tbltype key = tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsMake.Module_nameConsistbl.Makemodule Module_name : sig ... endval create : unit -> tval clear : t -> unitval check : t -> Module_name.t -> Stdlib.Digest.t -> Misc.filepath -> unitval check_noadd :
+ t ->
+ Module_name.t ->
+ Stdlib.Digest.t ->
+ Misc.filepath ->
+ unitval set : t -> Module_name.t -> Stdlib.Digest.t -> Misc.filepath -> unitval source : t -> Module_name.t -> Misc.filepathval extract :
+ Module_name.t list ->
+ t ->
+ (Module_name.t * Stdlib.Digest.t option) listval extract_map :
+ Module_name.Set.t ->
+ t ->
+ Stdlib.Digest.t option Module_name.Map.tval filter : (Module_name.t -> bool) -> t -> unitexception Inconsistency of {unit_name : Module_name.t;inconsistent_source : string;original_source : string;}exception Not_available of Module_name.tConsistblConsistency tables: for checking consistency of module CRCs
Warning: this module is unstable and part of compiler-libs.
module Make (Module_name : sig ... end) : sig ... endConvert_primitivesval convert : Lambda.primitive -> Clambda_primitives.primitiveCtypeexception Unify of Errortrace.unification_errorexception Equality of Errortrace.equality_errorexception Moregen of Errortrace.moregen_errorexception Subtype of Errortrace.Subtype.errorexception Escape of Types.type_expr Errortrace.escapeexception Tags of Asttypes.label * Asttypes.labelexception Matches_failure of Env.t * Errortrace.unification_errorval save_levels : unit -> levelsval set_levels : levels -> unitval newty : Types.type_desc -> Types.type_exprval new_scoped_ty : int -> Types.type_desc -> Types.type_exprval newvar : ?name:string -> unit -> Types.type_exprval newvar2 : ?name:string -> int -> Types.type_exprval new_global_var : ?name:string -> unit -> Types.type_exprval newobj : Types.type_expr -> Types.type_exprval newconstr : Path.t -> Types.type_expr list -> Types.type_exprval none : Types.type_exprval object_fields : Types.type_expr -> Types.type_exprval flatten_fields :
+ Types.type_expr ->
+ (string * Types.field_kind * Types.type_expr) list * Types.type_exprTransform a field type into a list of pairs label-type. The fields are sorted.
Beware of the interaction with GADTs:
Due to the introduction of object indexes for GADTs, the row variable of an object may now be an expansible type abbreviation. A first consequence is that flatten_fields will not completely flatten the object, since the type abbreviation will not be expanded (flatten_fields does not receive the current environment). Another consequence is that various functions may be called with the expansion of this type abbreviation, which is a Tfield, e.g. during printing.
Concrete problems have been fixed, but new bugs may appear in the future. (Test cases were added to typing-gadts/test.ml)
val associate_fields :
+ (string * Types.field_kind * Types.type_expr) list ->
+ (string * Types.field_kind * Types.type_expr) list ->
+ (string
+ * Types.field_kind
+ * Types.type_expr
+ * Types.field_kind
+ * Types.type_expr)
+ list
+ * (string * Types.field_kind * Types.type_expr) list
+ * (string * Types.field_kind * Types.type_expr) listval opened_object : Types.type_expr -> boolval set_object_name :
+ Ident.t ->
+ Types.type_expr list ->
+ Types.type_expr ->
+ unitval remove_object_name : Types.type_expr -> unitval find_cltype_for_path :
+ Env.t ->
+ Path.t ->
+ Types.type_declaration * Types.type_exprval sort_row_fields :
+ (Asttypes.label * Types.row_field) list ->
+ (Asttypes.label * Types.row_field) listval merge_row_fields :
+ (Asttypes.label * Types.row_field) list ->
+ (Asttypes.label * Types.row_field) list ->
+ (Asttypes.label * Types.row_field) list
+ * (Asttypes.label * Types.row_field) list
+ * (Asttypes.label * Types.row_field * Types.row_field) listval filter_row_fields :
+ bool ->
+ (Asttypes.label * Types.row_field) list ->
+ (Asttypes.label * Types.row_field) listval generalize : Types.type_expr -> unitval lower_contravariant : Env.t -> Types.type_expr -> unitval lower_variables_only : Env.t -> int -> Types.type_expr -> unitval generalize_structure : Types.type_expr -> unitval generalize_class_type : Types.class_type -> unitval generalize_class_type_structure : Types.class_type -> unitval generalize_class_signature_spine : Env.t -> Types.class_signature -> unitval correct_levels : Types.type_expr -> Types.type_exprval limited_generalize : Types.type_expr -> Types.type_expr -> unitval limited_generalize_class_type : Types.type_expr -> Types.class_type -> unitval fully_generic : Types.type_expr -> boolval check_scope_escape : Env.t -> int -> Types.type_expr -> unitval instance : ?partial:bool -> Types.type_expr -> Types.type_exprval generic_instance : Types.type_expr -> Types.type_exprval instance_list : Types.type_expr list -> Types.type_expr listval new_local_type :
+ ?loc:Location.t ->
+ ?manifest_and_scope:(Types.type_expr * int) ->
+ unit ->
+ Types.type_declarationval existential_name :
+ Types.constructor_description ->
+ Types.type_expr ->
+ stringval instance_constructor :
+ ?in_pattern:(Env.t ref * int) ->
+ Types.constructor_description ->
+ Types.type_expr list * Types.type_expr * Types.type_expr listval instance_parameterized_type :
+ ?keep_names:bool ->
+ Types.type_expr list ->
+ Types.type_expr ->
+ Types.type_expr list * Types.type_exprval instance_parameterized_type_2 :
+ Types.type_expr list ->
+ Types.type_expr list ->
+ Types.type_expr ->
+ Types.type_expr list * Types.type_expr list * Types.type_exprval instance_declaration : Types.type_declaration -> Types.type_declarationval generic_instance_declaration :
+ Types.type_declaration ->
+ Types.type_declarationval instance_class :
+ Types.type_expr list ->
+ Types.class_type ->
+ Types.type_expr list * Types.class_typeval instance_poly :
+ ?keep_names:bool ->
+ bool ->
+ Types.type_expr list ->
+ Types.type_expr ->
+ Types.type_expr list * Types.type_exprval polyfy :
+ Env.t ->
+ Types.type_expr ->
+ Types.type_expr list ->
+ Types.type_expr * boolval instance_label :
+ bool ->
+ Types.label_description ->
+ Types.type_expr list * Types.type_expr * Types.type_exprval apply :
+ Env.t ->
+ Types.type_expr list ->
+ Types.type_expr ->
+ Types.type_expr list ->
+ Types.type_exprval try_expand_once_opt : Env.t -> Types.type_expr -> Types.type_exprval try_expand_safe_opt : Env.t -> Types.type_expr -> Types.type_exprval expand_head_once : Env.t -> Types.type_expr -> Types.type_exprval expand_head : Env.t -> Types.type_expr -> Types.type_exprval expand_head_opt : Env.t -> Types.type_expr -> Types.type_exprThe compiler's own version of expand_head necessary for type-based optimisations.
Expansion of types for error traces; lives here instead of in Errortrace because the expansion machinery lives here.
val expanded_diff :
+ Env.t ->
+ got:Types.type_expr ->
+ expected:Types.type_expr ->
+ (Errortrace.expanded_type, 'variant) Errortrace.eltCreate an Errortrace.Diff by expanding the two types
val unexpanded_diff :
+ got:Types.type_expr ->
+ expected:Types.type_expr ->
+ (Errortrace.expanded_type, 'variant) Errortrace.eltCreate an Errortrace.Diff by *duplicating* the two types, so that each one's expansion is identical to itself. Despite the name, does create Errortrace.expanded_types.
val full_expand :
+ may_forget_scope:bool ->
+ Env.t ->
+ Types.type_expr ->
+ Types.type_exprtype typedecl_extraction_result = | Typedecl of Path.t * Path.t * Types.type_declaration| Has_no_typedecl| May_have_typedeclval extract_concrete_typedecl :
+ Env.t ->
+ Types.type_expr ->
+ typedecl_extraction_resultval unify : Env.t -> Types.type_expr -> Types.type_expr -> unitval unify_gadt :
+ equations_level:int ->
+ allow_recursive:bool ->
+ Env.t ref ->
+ Types.type_expr ->
+ Types.type_expr ->
+ Btype.TypePairs.tval unify_var : Env.t -> Types.type_expr -> Types.type_expr -> unitval filter_arrow :
+ Env.t ->
+ Types.type_expr ->
+ Asttypes.arg_label ->
+ Types.type_expr * Types.type_exprval filter_method : Env.t -> string -> Types.type_expr -> Types.type_exprval occur_in : Env.t -> Types.type_expr -> Types.type_expr -> boolval deep_occur : Types.type_expr -> Types.type_expr -> boolval moregeneral : Env.t -> bool -> Types.type_expr -> Types.type_expr -> unitval is_moregeneral :
+ Env.t ->
+ bool ->
+ Types.type_expr ->
+ Types.type_expr ->
+ boolval rigidify : Types.type_expr -> Types.type_expr listval all_distinct_vars : Env.t -> Types.type_expr list -> boolval matches :
+ expand_error_trace:bool ->
+ Env.t ->
+ Types.type_expr ->
+ Types.type_expr ->
+ unitval does_match : Env.t -> Types.type_expr -> Types.type_expr -> boolval reify_univars : Env.t -> Types.type_expr -> Types.type_exprtype filter_arrow_failure = | Unification_error of Errortrace.unification_error| Label_mismatch of {got : Asttypes.arg_label;expected : Asttypes.arg_label;expected_type : Types.type_expr;}| Not_a_functionexception Filter_arrow_failed of filter_arrow_failuretype filter_method_failure = | Unification_error of Errortrace.unification_error| Not_a_method| Not_an_object of Types.type_exprexception Filter_method_failed of filter_method_failuretype class_match_failure = | CM_Virtual_class| CM_Parameter_arity_mismatch of int * int| CM_Type_parameter_mismatch of Env.t * Errortrace.equality_error| CM_Class_type_mismatch of Env.t * Types.class_type * Types.class_type| CM_Parameter_mismatch of Env.t * Errortrace.moregen_error| CM_Val_type_mismatch of string * Env.t * Errortrace.comparison_error| CM_Meth_type_mismatch of string * Env.t * Errortrace.comparison_error| CM_Non_mutable_value of string| CM_Non_concrete_value of string| CM_Missing_value of string| CM_Missing_method of string| CM_Hide_public of string| CM_Hide_virtual of string * string| CM_Public_method of string| CM_Private_method of string| CM_Virtual_method of stringval match_class_types :
+ ?trace:bool ->
+ Env.t ->
+ Types.class_type ->
+ Types.class_type ->
+ class_match_failure listval equal :
+ Env.t ->
+ bool ->
+ Types.type_expr list ->
+ Types.type_expr list ->
+ unitval is_equal :
+ Env.t ->
+ bool ->
+ Types.type_expr list ->
+ Types.type_expr list ->
+ boolval equal_private :
+ Env.t ->
+ Types.type_expr list ->
+ Types.type_expr ->
+ Types.type_expr list ->
+ Types.type_expr ->
+ unitval match_class_declarations :
+ Env.t ->
+ Types.type_expr list ->
+ Types.class_type ->
+ Types.type_expr list ->
+ Types.class_type ->
+ class_match_failure listval enlarge_type : Env.t -> Types.type_expr -> Types.type_expr * boolval subtype : Env.t -> Types.type_expr -> Types.type_expr -> unit -> unitval new_class_signature : unit -> Types.class_signatureval add_dummy_method : Env.t -> scope:int -> Types.class_signature -> unitexception Add_method_failed of add_method_failureval add_method :
+ Env.t ->
+ Asttypes.label ->
+ Asttypes.private_flag ->
+ Asttypes.virtual_flag ->
+ Types.type_expr ->
+ Types.class_signature ->
+ unittype add_instance_variable_failure = | Mutability_mismatch of Asttypes.mutable_flag| Type_mismatch of Errortrace.unification_errorexception Add_instance_variable_failed of add_instance_variable_failureval add_instance_variable :
+ strict:bool ->
+ Env.t ->
+ Asttypes.label ->
+ Asttypes.mutable_flag ->
+ Asttypes.virtual_flag ->
+ Types.type_expr ->
+ Types.class_signature ->
+ unittype inherit_class_signature_failure = | Self_type_mismatch of Errortrace.unification_error| Method of Asttypes.label * add_method_failure| Instance_variable of Asttypes.label * add_instance_variable_failureexception Inherit_class_signature_failed of inherit_class_signature_failureval inherit_class_signature :
+ strict:bool ->
+ Env.t ->
+ Types.class_signature ->
+ Types.class_signature ->
+ unitval update_class_signature :
+ Env.t ->
+ Types.class_signature ->
+ Asttypes.label list * Asttypes.label listval hide_private_methods : Env.t -> Types.class_signature -> unitval close_class_signature : Env.t -> Types.class_signature -> boolexception Nondep_cannot_erase of Ident.tval nondep_type : Env.t -> Ident.t list -> Types.type_expr -> Types.type_exprval nondep_type_decl :
+ Env.t ->
+ Ident.t list ->
+ bool ->
+ Types.type_declaration ->
+ Types.type_declarationval nondep_extension_constructor :
+ Env.t ->
+ Ident.t list ->
+ Types.extension_constructor ->
+ Types.extension_constructorval nondep_class_declaration :
+ Env.t ->
+ Ident.t list ->
+ Types.class_declaration ->
+ Types.class_declarationval nondep_cltype_declaration :
+ Env.t ->
+ Ident.t list ->
+ Types.class_type_declaration ->
+ Types.class_type_declarationval normalize_type : Types.type_expr -> unitval nongen_schema : Env.t -> Types.type_expr -> boolval nongen_class_declaration : Types.class_declaration -> boolval free_variables : ?env:Env.t -> Types.type_expr -> Types.type_expr listval closed_type_decl : Types.type_declaration -> Types.type_expr optionval closed_extension_constructor :
+ Types.extension_constructor ->
+ Types.type_expr optionval closed_class :
+ Types.type_expr list ->
+ Types.class_signature ->
+ (Types.type_expr * bool * string * Types.type_expr) optionval unalias : Types.type_expr -> Types.type_exprval arity : Types.type_expr -> intval collapse_conj_params : Env.t -> Types.type_expr list -> unitval wrap_trace_gadt_instances : Env.t -> ('a -> 'b) -> 'a -> 'bval immediacy : Env.t -> Types.type_expr -> Type_immediacy.tval package_subtype :
+ (Env.t ->
+ Path.t ->
+ (Longident.t * Types.type_expr) list ->
+ Path.t ->
+ (Longident.t * Types.type_expr) list ->
+ bool)
+ refval mcomp : Env.t -> Types.type_expr -> Types.type_expr -> unitBackward.DDataflow.Backwardval analyze :
+ ?exnhandler:(D.t -> D.t) ->
+ ?exnescape:D.t ->
+ transfer:(Mach.instruction -> next:D.t -> exn:D.t -> D.t) ->
+ Mach.instruction ->
+ D.t * (int -> D.t)DataflowDataflow.DOMAINDatareprval extension_descr :
+ current_unit:string ->
+ Path.t ->
+ Types.extension_constructor ->
+ Types.constructor_descriptionval labels_of_type :
+ Path.t ->
+ Types.type_declaration ->
+ (Ident.t * Types.label_description) listval constructors_of_type :
+ current_unit:string ->
+ Path.t ->
+ Types.type_declaration ->
+ (Ident.t * Types.constructor_description) listval find_constr_by_tag :
+ Types.constructor_tag ->
+ Types.constructor_declaration list ->
+ Types.constructor_declarationval constructor_existentials :
+ Types.constructor_arguments ->
+ Types.type_expr option ->
+ Types.type_expr list * Types.type_expr listTakes cd_args and cd_res from a constructor_declaration and returns:
Deadcodeval fundecl : Mach.fundecl -> Mach.fundeclDebuginfo.Scoped_locationval string_of_scopes : scopes -> stringval empty_scopes : scopesval enter_method_definition : scopes:scopes -> Asttypes.label -> scopesval of_location : scopes:scopes -> Location.t -> tval to_location : t -> Location.tval string_of_scoped_location : t -> stringDebuginfomodule Scoped_location : sig ... endtype item = private {dinfo_file : string;dinfo_line : int;dinfo_char_start : int;dinfo_char_end : int;dinfo_start_bol : int;dinfo_end_bol : int;dinfo_end_line : int;dinfo_scopes : Scoped_location.scopes;}type t = item listDue to Comballoc, a single Ialloc instruction may combine several unrelated allocations. Their Debuginfo.t (which may differ) are stored as a list of alloc_dbginfo. This list is in order of increasing memory address, which is the reverse of the original allocation order. Later allocations are consed to the front of this list by Comballoc.
type alloc_dbginfo = alloc_dbginfo_item listval none : tval is_none : t -> boolval to_string : t -> stringval from_location : Scoped_location.t -> tval to_location : t -> Location.tval hash : t -> intval print_compact : Stdlib.Format.formatter -> t -> unitDependModule dependencies.
Warning: this module is unstable and part of compiler-libs.
module String = Misc.Stdlib.Stringand bound_map = map_tree String.Map.tval make_leaf : string -> map_treeval weaken_map : String.Set.t -> map_tree -> map_treeval free_structure_names : String.Set.t refval pp_deps : string list refdependencies found by preprocessing tools
val open_module : bound_map -> Longident.t -> bound_mapval add_use_file : bound_map -> Parsetree.toplevel_phrase list -> unitval add_signature : bound_map -> Parsetree.signature -> unitval add_implementation : bound_map -> Parsetree.structure -> unitval add_implementation_binding : bound_map -> Parsetree.structure -> bound_mapval add_signature_binding : bound_map -> Parsetree.signature -> bound_mapLeft_variadic._val weight : change -> intweight ch returns the weight of the change ch. Used to find the smallest patch.
test st xl xr tests if the elements xl and xr are co mpatible (Ok) or not (Error).
Define.Left_variadicVariadic diffing allows to expand the lists being diffed during diffing. in one specific direction.
module _ : Parameters with type update_result := D.state * D.left arrayRight_variadic._val weight : change -> intweight ch returns the weight of the change ch. Used to find the smallest patch.
test st xl xr tests if the elements xl and xr are co mpatible (Ok) or not (Error).
Define.Right_variadicSimple._val weight : change -> intweight ch returns the weight of the change ch. Used to find the smallest patch.
test st xl xr tests if the elements xl and xr are co mpatible (Ok) or not (Error).
Define.SimpleDefine.DDiffing.DefineDefine(Defs) creates the diffing types from the types defined in Defs and the functors that need to be instantatied with the diffing algorithm parameters
type patch = change listA patch is an ordered list of changes.
module type Parameters = sig ... endmodule type S = sig ... endmodule Simple (_ : Parameters with type update_result := D.state) : Smodule Left_variadic
+ (_ : Parameters with type update_result := D.state * D.left array) :
+ Smodule Right_variadic
+ (_ : Parameters with type update_result := D.state * D.right array) :
+ SDefine.Parametersval weight : change -> intweight ch returns the weight of the change ch. Used to find the smallest patch.
test st xl xr tests if the elements xl and xr are co mpatible (Ok) or not (Error).
val update : change -> D.state -> update_resultupdate ch st returns the new state after applying a change. The update_result type also contains expansions in the variadic case.
Define.SDiffingParametric diffing
This module implements diffing over lists of arbitrary content. It is parameterized by
Diffing is extended to maintain state depending on the computed changes while walking through the two lists.
The underlying algorithm is a modified Wagner-Fischer algorithm (see <https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm>).
We provide the following guarantee: Given two lists l and r, if different patches result in different states, we say that the state diverges.
l and r on which state does not diverge.More precisely, the optimality of Wagner-Fischer depends on the property that the edit-distance between a k-prefix of the left input and a l-prefix of the right input d(k,l) satisfies
d(k,l) = min ( del_cost + d(k-1,l), insert_cost + d(k,l-1), change_cost + d(k-1,l-1) )
Under this hypothesis, it is optimal to choose greedily the state of the minimal patch transforming the left k-prefix into the right l-prefix as a representative of the states of all possible patches transforming the left k-prefix into the right l-prefix.
If this property is not satisfied, we can still choose greedily a representative state. However, the computed patch is no more guaranteed to be globally optimal. Nevertheless, it is still a correct patch, which is even optimal among all explored patches.
module type Defs = sig ... endThe core types of a diffing implementation
The kind of changes which is used to share printing and styling across implementation
val prefix : Stdlib.Format.formatter -> (int * change_kind) -> unitval style : change_kind -> Misc.Color.style listval classify : (_, _, _, _) change -> change_kindDiffing.DefsThe core types of a diffing implementation
Simple._Define.SimpleDefine.DDiffing_with_keys.Definemodule D : Diffing.Defs with type eq := unittype patch = composite_change listtype change = (left, right, unit, diff) Diffing.changeAtomic changes
module type Parameters = sig ... endmodule Simple (_ : Parameters) : sig ... endDefine.ParametersDiffing_with_keysWhen diffing lists where each element has a distinct key, we can refine the diffing patch by introducing two composite edit moves: swaps and moves.
Swaps exchange the position of two elements. Swap cost is set to 2 * change - epsilon. Moves change the position of one element. Move cost is set to delete + addition - epsilon.
When the cost delete + addition is greater than change and with those specific weights, the optimal patch with Swaps and Moves can be computed directly and cheaply from the original optimal patch.
val with_pos : 'a list -> 'a with_pos listtype ('l, 'r, 'diff) change = | Change of ('l, 'r, 'diff) mismatch| Swap of {}| Move of {}| Insert of {}| Delete of {}This specialized version of changes introduces two composite changes: Move and Swap
val prefix : Stdlib.Format.formatter -> ('l, 'r, 'diff) change -> unitmodule Define (D : Diffing.Defs with type eq := unit) : sig ... endDllval open_dlls : dll_mode -> string list -> unitval find_primitive : string -> primitive_address optionval synchronize_primitive : int -> dll_address -> unitDocstrings.WithMenhirval symbol_docs : (Stdlib.Lexing.position * Stdlib.Lexing.position) -> docsFetch the item documentation for the current symbol. This also marks this documentation (for ambiguity warnings).
val symbol_docs_lazy :
+ (Stdlib.Lexing.position * Stdlib.Lexing.position) ->
+ docs Stdlib.Lazy.tval rhs_docs : Stdlib.Lexing.position -> Stdlib.Lexing.position -> docsFetch the item documentation for the symbols between two positions. This also marks this documentation (for ambiguity warnings).
val rhs_docs_lazy :
+ Stdlib.Lexing.position ->
+ Stdlib.Lexing.position ->
+ docs Stdlib.Lazy.tval mark_symbol_docs :
+ (Stdlib.Lexing.position * Stdlib.Lexing.position) ->
+ unitMark the item documentation for the current symbol (for ambiguity warnings).
val mark_rhs_docs : Stdlib.Lexing.position -> Stdlib.Lexing.position -> unitMark as associated the item documentation for the symbols between two positions (for ambiguity warnings)
val symbol_info : Stdlib.Lexing.position -> infoFetch the field info for the current symbol.
val rhs_info : Stdlib.Lexing.position -> infoFetch the field info following the symbol at a given position.
val symbol_text : Stdlib.Lexing.position -> textFetch the text preceding the current symbol.
val symbol_text_lazy : Stdlib.Lexing.position -> text Stdlib.Lazy.tval rhs_text : Stdlib.Lexing.position -> textFetch the text preceding the symbol at the given position.
val rhs_text_lazy : Stdlib.Lexing.position -> text Stdlib.Lazy.tThere may be additional text attached to the delimiters of a block (e.g. struct and end). This is fetched by the following functions, which are applied to the contents of the block rather than the delimiters.
val symbol_pre_extra_text : Stdlib.Lexing.position -> textFetch additional text preceding the current symbol
val symbol_post_extra_text : Stdlib.Lexing.position -> textFetch additional text following the current symbol
val rhs_pre_extra_text : Stdlib.Lexing.position -> textFetch additional text preceding the symbol at the given position
val rhs_post_extra_text : Stdlib.Lexing.position -> textFetch additional text following the symbol at the given position
val rhs_post_text : Stdlib.Lexing.position -> textFetch text following the symbol at the given position
DocstringsDocumentation comments
Warning: this module is unstable and part of compiler-libs.
val docstring : string -> Location.t -> docstringCreate a docstring
val register : docstring -> unitRegister a docstring
val docstring_body : docstring -> stringGet the text of a docstring
val docstring_loc : docstring -> Location.tGet the location of a docstring
These functions are used by the lexer to associate docstrings to the locations of tokens.
val set_pre_docstrings : Stdlib.Lexing.position -> docstring list -> unitDocstrings immediately preceding a token
val set_post_docstrings : Stdlib.Lexing.position -> docstring list -> unitDocstrings immediately following a token
val set_floating_docstrings : Stdlib.Lexing.position -> docstring list -> unitDocstrings not immediately adjacent to a token
val set_pre_extra_docstrings : Stdlib.Lexing.position -> docstring list -> unitDocstrings immediately following the token which precedes this one
val set_post_extra_docstrings :
+ Stdlib.Lexing.position ->
+ docstring list ->
+ unitDocstrings immediately preceding the token which follows this one
The docs type represents documentation attached to an item.
val empty_docs : docsval docs_attr : docstring -> Parsetree.attributeval add_docs_attrs : docs -> Parsetree.attributes -> Parsetree.attributesConvert item documentation to attributes and add them to an attribute list
val symbol_docs : unit -> docsFetch the item documentation for the current symbol. This also marks this documentation (for ambiguity warnings).
val symbol_docs_lazy : unit -> docs Stdlib.Lazy.tval rhs_docs : int -> int -> docsFetch the item documentation for the symbols between two positions. This also marks this documentation (for ambiguity warnings).
val rhs_docs_lazy : int -> int -> docs Stdlib.Lazy.tMark the item documentation for the current symbol (for ambiguity warnings).
Mark as associated the item documentation for the symbols between two positions (for ambiguity warnings)
The info type represents documentation attached to a field or constructor.
type info = docstring optionval empty_info : infoval info_attr : docstring -> Parsetree.attributeval add_info_attrs : info -> Parsetree.attributes -> Parsetree.attributesConvert field info to attributes and add them to an attribute list
val symbol_info : unit -> infoFetch the field info for the current symbol.
val rhs_info : int -> infoFetch the field info following the symbol at a given position.
The text type represents documentation which is not attached to anything.
type text = docstring listval empty_text : textval empty_text_lazy : text Stdlib.Lazy.tval text_attr : docstring -> Parsetree.attributeval add_text_attrs : text -> Parsetree.attributes -> Parsetree.attributesConvert text to attributes and add them to an attribute list
val symbol_text : unit -> textFetch the text preceding the current symbol.
val symbol_text_lazy : unit -> text Stdlib.Lazy.tval rhs_text : int -> textFetch the text preceding the symbol at the given position.
val rhs_text_lazy : int -> text Stdlib.Lazy.tThere may be additional text attached to the delimiters of a block (e.g. struct and end). This is fetched by the following functions, which are applied to the contents of the block rather than the delimiters.
val symbol_pre_extra_text : unit -> textFetch additional text preceding the current symbol
val symbol_post_extra_text : unit -> textFetch additional text following the current symbol
val rhs_pre_extra_text : int -> textFetch additional text preceding the symbol at the given position
val rhs_post_extra_text : int -> textFetch additional text following the symbol at the given position
val rhs_post_text : int -> textFetch text following the symbol at the given position
module WithMenhir : sig ... endDomainstatetype t = | Domain_young_limit| Domain_young_ptr| Domain_exception_pointer| Domain_young_base| Domain_young_start| Domain_young_end| Domain_young_alloc_start| Domain_young_alloc_end| Domain_young_alloc_mid| Domain_young_trigger| Domain_minor_heap_wsz| Domain_in_minor_collection| Domain_extra_heap_resources_minor| Domain_ref_table| Domain_ephe_ref_table| Domain_custom_table| Domain_mark_stack| Domain_stack_low| Domain_stack_high| Domain_stack_threshold| Domain_extern_sp| Domain_trapsp| Domain_trap_barrier| Domain_external_raise| Domain_exn_bucket| Domain_top_of_stack| Domain_bottom_of_stack| Domain_last_return_address| Domain_gc_regs| Domain_backtrace_active| Domain_backtrace_pos| Domain_backtrace_buffer| Domain_backtrace_last_exn| Domain_compare_unordered| Domain_requested_major_slice| Domain_requested_minor_gc| Domain_local_roots| Domain_stat_minor_words| Domain_stat_promoted_words| Domain_stat_major_words| Domain_stat_minor_collections| Domain_stat_major_collections| Domain_stat_heap_wsz| Domain_stat_top_heap_wsz| Domain_stat_compactions| Domain_stat_forced_major_collections| Domain_stat_heap_chunks| Domain_eventlog_startup_timestamp| Domain_eventlog_startup_pid| Domain_eventlog_paused| Domain_eventlog_enabled| Domain_eventlog_out| Domain_extra_paramsval idx_of_field : t -> intDynlinkDynamic loading of .cmo, .cma and .cmxs files.
In bytecode: load the given bytecode object file (.cmo file) or bytecode library file (.cma file), and link it with the running program. In native code: load the given OCaml plugin file (usually .cmxs), and link it with the running program.
All toplevel expressions in the loaded compilation units are evaluated. No facilities are provided to access value names defined by the unit. Therefore, the unit must itself register its entry points with the main program (or a previously-loaded library) e.g. by modifying tables of functions.
An exception will be raised if the given library defines toplevel modules whose names clash with modules existing either in the main program or a shared library previously loaded with loadfile. Modules from shared libraries previously loaded with loadfile_private are not included in this restriction.
The compilation units loaded by this function are added to the "allowed units" list (see set_allowed_units).
Same as loadfile, except that the compilation units just loaded are hidden (cannot be referenced) from other modules dynamically loaded afterwards.
An exception will be raised if the given library defines toplevel modules whose names clash with modules existing in either the main program or a shared library previously loaded with loadfile. Modules from shared libraries previously loaded with loadfile_private are not included in this restriction.
An exception will also be raised if the given library defines toplevel modules whose name matches that of an interface depended on by a module existing in either the main program or a shared library previously loaded with loadfile. This applies even if such dependency is only a "module alias" dependency (i.e. just on the name rather than the contents of the interface).
The compilation units loaded by this function are not added to the "allowed units" list (see set_allowed_units) since they cannot be referenced from other compilation units.
In bytecode, the identity function. In native code, replace the last extension with .cmxs.
Set the list of compilation units that may be referenced from units that are dynamically loaded in the future to be exactly the given value.
Initially all compilation units composing the program currently running are available for reference from dynamically-linked units. set_allowed_units can be used to restrict access to a subset of these units, e.g. to the units that compose the API for dynamically-linked code, and prevent access to all other units, e.g. private, internal modules of the running program.
Note that loadfile changes the allowed-units list.
allow_only units sets the list of allowed units to be the intersection of the existing allowed units and the given list of units. As such it can never increase the set of allowed units.
prohibit units prohibits dynamically-linked units from referencing the units named in list units by removing such units from the allowed units list. This can be used to prevent access to selected units, e.g. private, internal modules of the running program.
Return the list of compilation units that form the main program (i.e. are not dynamically linked).
Return the list of compilation units that have been dynamically loaded via loadfile (and not via loadfile_private). Note that compilation units loaded dynamically cannot be unloaded.
Return the list of compilation units that form the main program together with those that have been dynamically loaded via loadfile (and not via loadfile_private).
Govern whether unsafe object files are allowed to be dynamically linked. A compilation unit is 'unsafe' if it contains declarations of external functions, which can break type safety. By default, dynamic linking of unsafe object files is not allowed. In native code, this function does nothing; object files with external functions are always allowed to be dynamically linked.
type error = private | Not_a_bytecode_file of string| Inconsistent_import of string| Unsafe_file| Linking_error of string * linking_error| Corrupted_interface of string| Cannot_open_dynamic_library of exn| Library's_module_initializers_failed of exn| Inconsistent_implementation of string| Module_already_loaded of string| Private_library_cannot_implement_interface of stringexception Error of errorErrors in dynamic linking are reported by raising the Error exception with a description of the error. A common case is the dynamic library not being found on the system: this is reported via Cannot_open_dynamic_library (the enclosed exception may be platform-specific).
val error_message : error -> stringConvert an error description to a printable message.
Effect_analysisSimple side effect analysis.
val no_effects : Flambda.t -> boolConservative approximation as to whether a given Flambda expression may have any side effects.
val no_effects_named : Flambda.named -> boolEmitval fundecl : Linear.fundecl -> unitval data : Cmm.data_item list -> unitEmitauxval output_channel : out_channel refval emit_printf : ('a, out_channel, unit) format -> 'aval emit_debug_info : Debuginfo.t -> unitval emit_debug_info_gen :
+ Debuginfo.t ->
+ (file_num:int -> file_name:string -> unit) ->
+ (file_num:int -> line:int -> col:int -> unit) ->
+ unittype frame_debuginfo = | Dbg_alloc of Debuginfo.alloc_dbginfo| Dbg_raise of Debuginfo.t| Dbg_other of Debuginfo.tval record_frame_descr :
+ label:int ->
+ frame_size:int ->
+ live_offset:int list ->
+ frame_debuginfo ->
+ unitval emit_frames : emit_frame_actions -> unitval binary_backend_available : bool refIs a binary backend available. If yes, we don't need to generate the textual assembly file (unless the user request it with -S).
val create_asm_file : bool refAre we actually generating the textual assembly file?
exception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitval mk_env : Linear.fundecl -> Emitenv.per_function_envEmitcodeval to_file :
+ out_channel ->
+ string ->
+ string ->
+ required_globals:Ident.Set.t ->
+ Instruct.instruction list ->
+ unitval to_memory :
+ Instruct.instruction list ->
+ Instruct.instruction list ->
+ Misc.LongString.t
+ * (Cmo_format.reloc_info * int) list
+ * Instruct.debug_event listval to_packed_file :
+ out_channel ->
+ Instruct.instruction list ->
+ (Cmo_format.reloc_info * int) listval marshal_to_channel_with_possibly_32bit_compat :
+ filename:string ->
+ kind:string ->
+ out_channel ->
+ 'a ->
+ unitEmitenvtype label = Linear.labeltype per_function_env = {f : Linear.fundecl;mutable stack_offset : int;mutable call_gc_sites : gc_call list;mutable call_gc_label : label;mutable bound_error_sites : bound_error_call list;mutable bound_error_call : label option;mutable jumptables_lbl : label option;mutable jumptables : label list;mutable float_literals : float_literal list;mutable int_literals : int_literal list;mutable offset_literals : offset_computation list;mutable gotrel_literals : gotrel_literal list;mutable symbol_literals : symbol_literal list;mutable size_literals : int;}Envval register_uid : Types.Uid.t -> Location.t -> unitval get_uid_to_loc_tbl : unit -> Location.t Types.Uid.Tbl.ttype value_unbound_reason = | Val_unbound_instance_variable| Val_unbound_self| Val_unbound_ancestor| Val_unbound_ghost_recursive of Location.ttype summary = | Env_empty| Env_value of summary * Ident.t * Types.value_description| Env_type of summary * Ident.t * Types.type_declaration| Env_extension of summary * Ident.t * Types.extension_constructor| Env_module of summary
+ * Ident.t
+ * Types.module_presence
+ * Types.module_declaration| Env_modtype of summary * Ident.t * Types.modtype_declaration| Env_class of summary * Ident.t * Types.class_declaration| Env_cltype of summary * Ident.t * Types.class_type_declaration| Env_open of summary * Path.tThe string set argument of Env_open represents a list of module names to skip, i.e. that won't be imported in the toplevel namespace.
| Env_functor_arg of summary * Ident.t| Env_constraints of summary * Types.type_declaration Path.Map.t| Env_copy_types of summary| Env_persistent of summary * Ident.t| Env_value_unbound of summary * string * value_unbound_reason| Env_module_unbound of summary * string * module_unbound_reasonval empty : tval initial_safe_string : tval initial_unsafe_string : ttype type_descr_kind =
+ (Types.label_description, Types.constructor_description) Types.type_kindtype type_descriptions = type_descr_kindval iter_types :
+ (Path.t -> (Path.t * Types.type_declaration) -> unit) ->
+ t ->
+ iter_contval used_persistent : unit -> Misc.Stdlib.String.Set.tval find_value : Path.t -> t -> Types.value_descriptionval find_type : Path.t -> t -> Types.type_declarationval find_type_descrs : Path.t -> t -> type_descriptionsval find_module : Path.t -> t -> Types.module_declarationval find_modtype : Path.t -> t -> Types.modtype_declarationval find_class : Path.t -> t -> Types.class_declarationval find_cltype : Path.t -> t -> Types.class_type_declarationval find_strengthened_module :
+ aliasable:bool ->
+ Path.t ->
+ t ->
+ Types.module_typeval find_ident_constructor : Ident.t -> t -> Types.constructor_descriptionval find_ident_label : Ident.t -> t -> Types.label_descriptionval find_type_expansion :
+ Path.t ->
+ t ->
+ Types.type_expr list * Types.type_expr * intval find_type_expansion_opt :
+ Path.t ->
+ t ->
+ Types.type_expr list * Types.type_expr * intval find_modtype_expansion : Path.t -> t -> Types.module_typeval find_modtype_expansion_lazy : Path.t -> t -> Subst.Lazy.modtypeval find_hash_type : Path.t -> t -> Types.type_declarationval shape_of_path :
+ namespace:Shape.Sig_component_kind.t ->
+ t ->
+ Path.t ->
+ Shape.tval normalize_module_path : Location.t option -> t -> Path.t -> Path.tval normalize_type_path : Location.t option -> t -> Path.t -> Path.tval normalize_path_prefix : Location.t option -> t -> Path.t -> Path.tval get_required_globals : unit -> Ident.t listval add_required_global : Ident.t -> unitval has_local_constraints : t -> boolval mark_value_used : Types.Uid.t -> unitval mark_module_used : Types.Uid.t -> unitval mark_type_used : Types.Uid.t -> unitval mark_constructor_used :
+ constructor_usage ->
+ Types.constructor_declaration ->
+ unitval mark_extension_used :
+ constructor_usage ->
+ Types.extension_constructor ->
+ unitval mark_label_used : label_usage -> Types.label_declaration -> unittype lookup_error = | Unbound_value of Longident.t * unbound_value_hint| Unbound_type of Longident.t| Unbound_constructor of Longident.t| Unbound_label of Longident.t| Unbound_module of Longident.t| Unbound_class of Longident.t| Unbound_modtype of Longident.t| Unbound_cltype of Longident.t| Unbound_instance_variable of string| Not_an_instance_variable of string| Masked_instance_variable of Longident.t| Masked_self_variable of Longident.t| Masked_ancestor_variable of Longident.t| Structure_used_as_functor of Longident.t| Abstract_used_as_functor of Longident.t| Functor_used_as_structure of Longident.t| Abstract_used_as_structure of Longident.t| Generative_used_as_applicative of Longident.t| Illegal_reference_to_recursive_module| Cannot_scrape_alias of Longident.t * Path.tval lookup_error : Location.t -> t -> lookup_error -> 'aval lookup_value :
+ ?use:bool ->
+ loc:Location.t ->
+ Longident.t ->
+ t ->
+ Path.t * Types.value_descriptionval lookup_type :
+ ?use:bool ->
+ loc:Location.t ->
+ Longident.t ->
+ t ->
+ Path.t * Types.type_declarationval lookup_module :
+ ?use:bool ->
+ loc:Location.t ->
+ Longident.t ->
+ t ->
+ Path.t * Types.module_declarationval lookup_modtype :
+ ?use:bool ->
+ loc:Location.t ->
+ Longident.t ->
+ t ->
+ Path.t * Types.modtype_declarationval lookup_class :
+ ?use:bool ->
+ loc:Location.t ->
+ Longident.t ->
+ t ->
+ Path.t * Types.class_declarationval lookup_cltype :
+ ?use:bool ->
+ loc:Location.t ->
+ Longident.t ->
+ t ->
+ Path.t * Types.class_type_declarationval lookup_module_path :
+ ?use:bool ->
+ loc:Location.t ->
+ load:bool ->
+ Longident.t ->
+ t ->
+ Path.tval lookup_modtype_path :
+ ?use:bool ->
+ loc:Location.t ->
+ Longident.t ->
+ t ->
+ Path.tval lookup_constructor :
+ ?use:bool ->
+ loc:Location.t ->
+ constructor_usage ->
+ Longident.t ->
+ t ->
+ Types.constructor_descriptionval lookup_all_constructors :
+ ?use:bool ->
+ loc:Location.t ->
+ constructor_usage ->
+ Longident.t ->
+ t ->
+ ((Types.constructor_description * (unit -> unit)) list,
+ Location.t * t * lookup_error)
+ resultval lookup_all_constructors_from_type :
+ ?use:bool ->
+ loc:Location.t ->
+ constructor_usage ->
+ Path.t ->
+ t ->
+ (Types.constructor_description * (unit -> unit)) listval lookup_label :
+ ?use:bool ->
+ loc:Location.t ->
+ label_usage ->
+ Longident.t ->
+ t ->
+ Types.label_descriptionval lookup_all_labels :
+ ?use:bool ->
+ loc:Location.t ->
+ label_usage ->
+ Longident.t ->
+ t ->
+ ((Types.label_description * (unit -> unit)) list,
+ Location.t * t * lookup_error)
+ resultval lookup_all_labels_from_type :
+ ?use:bool ->
+ loc:Location.t ->
+ label_usage ->
+ Path.t ->
+ t ->
+ (Types.label_description * (unit -> unit)) listval lookup_instance_variable :
+ ?use:bool ->
+ loc:Location.t ->
+ string ->
+ t ->
+ Path.t * Asttypes.mutable_flag * string * Types.type_exprval find_value_by_name : Longident.t -> t -> Path.t * Types.value_descriptionval find_type_by_name : Longident.t -> t -> Path.t * Types.type_declarationval find_module_by_name : Longident.t -> t -> Path.t * Types.module_declarationval find_modtype_by_name :
+ Longident.t ->
+ t ->
+ Path.t * Types.modtype_declarationval find_class_by_name : Longident.t -> t -> Path.t * Types.class_declarationval find_cltype_by_name :
+ Longident.t ->
+ t ->
+ Path.t * Types.class_type_declarationval find_constructor_by_name :
+ Longident.t ->
+ t ->
+ Types.constructor_descriptionval find_label_by_name : Longident.t -> t -> Types.label_descriptionval bound_value : string -> t -> boolval bound_module : string -> t -> boolval bound_type : string -> t -> boolval bound_modtype : string -> t -> boolval bound_class : string -> t -> boolval bound_cltype : string -> t -> boolval add_value :
+ ?check:(string -> Warnings.t) ->
+ Ident.t ->
+ Types.value_description ->
+ t ->
+ tval add_type : check:bool -> Ident.t -> Types.type_declaration -> t -> tval add_extension :
+ check:bool ->
+ rebind:bool ->
+ Ident.t ->
+ Types.extension_constructor ->
+ t ->
+ tval add_module :
+ ?arg:bool ->
+ ?shape:Shape.t ->
+ Ident.t ->
+ Types.module_presence ->
+ Types.module_type ->
+ t ->
+ tval add_module_lazy :
+ update_summary:bool ->
+ Ident.t ->
+ Types.module_presence ->
+ Subst.Lazy.modtype ->
+ t ->
+ tval add_module_declaration :
+ ?arg:bool ->
+ ?shape:Shape.t ->
+ check:bool ->
+ Ident.t ->
+ Types.module_presence ->
+ Types.module_declaration ->
+ t ->
+ tval add_module_declaration_lazy :
+ update_summary:bool ->
+ Ident.t ->
+ Types.module_presence ->
+ Subst.Lazy.module_decl ->
+ t ->
+ tval add_modtype : Ident.t -> Types.modtype_declaration -> t -> tval add_modtype_lazy :
+ update_summary:bool ->
+ Ident.t ->
+ Subst.Lazy.modtype_declaration ->
+ t ->
+ tval add_class : Ident.t -> Types.class_declaration -> t -> tval add_cltype : Ident.t -> Types.class_type_declaration -> t -> tval add_local_type : Path.t -> Types.type_declaration -> t -> tval persistent_structures_of_dir : Load_path.Dir.t -> Misc.Stdlib.String.Set.tval add_signature : Types.signature -> t -> tval open_signature :
+ ?used_slot:bool ref ->
+ ?loc:Location.t ->
+ ?toplevel:bool ->
+ Asttypes.override_flag ->
+ Path.t ->
+ t ->
+ (t, [ `Not_found | `Functor ]) resultval enter_value :
+ ?check:(string -> Warnings.t) ->
+ string ->
+ Types.value_description ->
+ t ->
+ Ident.t * tval enter_type :
+ scope:int ->
+ string ->
+ Types.type_declaration ->
+ t ->
+ Ident.t * tval enter_extension :
+ scope:int ->
+ rebind:bool ->
+ string ->
+ Types.extension_constructor ->
+ t ->
+ Ident.t * tval enter_module :
+ scope:int ->
+ ?arg:bool ->
+ string ->
+ Types.module_presence ->
+ Types.module_type ->
+ t ->
+ Ident.t * tval enter_module_declaration :
+ scope:int ->
+ ?arg:bool ->
+ ?shape:Shape.t ->
+ string ->
+ Types.module_presence ->
+ Types.module_declaration ->
+ t ->
+ Ident.t * tval enter_modtype :
+ scope:int ->
+ string ->
+ Types.modtype_declaration ->
+ t ->
+ Ident.t * tval enter_class :
+ scope:int ->
+ string ->
+ Types.class_declaration ->
+ t ->
+ Ident.t * tval enter_cltype :
+ scope:int ->
+ string ->
+ Types.class_type_declaration ->
+ t ->
+ Ident.t * tval enter_signature :
+ ?mod_shape:Shape.t ->
+ scope:int ->
+ Types.signature ->
+ t ->
+ Types.signature * tval enter_signature_and_shape :
+ scope:int ->
+ parent_shape:Shape.Map.t ->
+ Shape.t ->
+ Types.signature ->
+ t ->
+ Types.signature * Shape.Map.t * tval enter_unbound_value : string -> value_unbound_reason -> t -> tval enter_unbound_module : string -> module_unbound_reason -> t -> tval read_signature : Misc.modname -> Misc.filepath -> Types.signatureval save_signature :
+ alerts:Misc.alerts ->
+ Types.signature ->
+ Misc.modname ->
+ Misc.filepath ->
+ Cmi_format.cmi_infosval save_signature_with_imports :
+ alerts:Misc.alerts ->
+ Types.signature ->
+ Misc.modname ->
+ Misc.filepath ->
+ Misc.crcs ->
+ Cmi_format.cmi_infosval crc_of_unit : Misc.modname -> Stdlib.Digest.tval imports : unit -> Misc.crcsval import_crcs : source:string -> Misc.crcs -> unitval is_imported_opaque : Misc.modname -> boolval register_import_as_opaque : Misc.modname -> unittype error = | Missing_module of Location.t * Path.t * Path.t| Illegal_value_name of Location.t * string| Lookup_error of Location.t * t * lookup_errorexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitval report_lookup_error :
+ Location.t ->
+ t ->
+ Stdlib.Format.formatter ->
+ lookup_error ->
+ unitval is_in_signature : t -> boolval set_value_used_callback : Types.value_description -> (unit -> unit) -> unitval set_type_used_callback :
+ Types.type_declaration ->
+ ((unit -> unit) -> unit) ->
+ unitval check_functor_application :
+ (errors:bool ->
+ loc:Location.t ->
+ lid_whole_app:Longident.t ->
+ f0_path:Path.t ->
+ args:(Path.t * Types.module_type) list ->
+ arg_path:Path.t ->
+ arg_mty:Types.module_type ->
+ param_mty:Types.module_type ->
+ t ->
+ unit)
+ refval check_well_formed_module :
+ (t -> Location.t -> string -> Types.module_type -> unit) refval add_delayed_check_forward : ((unit -> unit) -> unit) refval strengthen :
+ (aliasable:bool ->
+ t ->
+ Subst.Lazy.modtype ->
+ Path.t ->
+ Subst.Lazy.modtype)
+ refval same_constr : (t -> Types.type_expr -> Types.type_expr -> bool) refval print_longident : (Stdlib.Format.formatter -> Longident.t -> unit) refval print_path : (Stdlib.Format.formatter -> Path.t -> unit) refFolds
val fold_values :
+ (string -> Path.t -> Types.value_description -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aval fold_types :
+ (string -> Path.t -> Types.type_declaration -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aval fold_constructors :
+ (Types.constructor_description -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aval fold_labels :
+ (Types.label_description -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aval fold_modules :
+ (string -> Path.t -> Types.module_declaration -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aPersistent structures are only traversed if they are already loaded.
val fold_modtypes :
+ (string -> Path.t -> Types.modtype_declaration -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aval fold_classes :
+ (string -> Path.t -> Types.class_declaration -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aval fold_cltypes :
+ (string -> Path.t -> Types.class_type_declaration -> 'a -> 'a) ->
+ Longident.t option ->
+ t ->
+ 'a ->
+ 'aval scrape_alias : t -> Types.module_type -> Types.module_typeUtilities
val check_value_name : string -> Location.t -> unitval print_address : Stdlib.Format.formatter -> address -> unitEnvauxval env_from_summary : Env.summary -> Subst.t -> Env.texception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitErrorsval report_error : Stdlib.Format.formatter -> exn -> unitErrortrace.Subtypetype 'a t = 'a elt listJust as outside Subtype, we split traces, completed traces, and complete errors. However, in a minor asymmetry, the name Subtype.error_trace corresponds to the outside error type, and Subtype.error corresponds to the outside *_error types (e.g., unification_error). This error type has the invariant that the subtype trace is nonempty; note that no such invariant is imposed on the unification trace.
type trace = Types.type_expr ttype error_trace = expanded_type ttype unification_error_trace = unification errorTo avoid shadowing
val error :
+ trace:error_trace ->
+ unification_trace:unification_error_trace ->
+ errorErrortraceval print_pos : Stdlib.Format.formatter -> position -> unitval trivial_expansion : Types.type_expr -> expanded_typetrivial_expansion ty creates an expanded_type whose expansion is also ty. Usually, you want Ctype.expand_type instead, since the expansion carries useful information; however, in certain circumstances, the error is about the expansion of the type, meaning that actually performing the expansion produces more confusing or inaccurate output.
map_diff f {expected;got} is {expected=f expected; got=f got}
type 'a escape_kind = | Constructor of Path.t| Univ of Types.type_expr| Self| Module_type of Path.t| Equation of 'a| ConstraintScope escape related errors
type 'variety variant = | Incompatible_types_for : string -> _ variant| No_intersection : unification variant| Fixed_row : position
+ * fixed_row_case
+ * Types.fixed_explanation -> unification variant| Presence_not_guaranteed_for : position * string -> comparison variant| Openness : position -> comparison varianttype ('a, 'variety) elt = | Diff : 'a diff -> ('a, _) elt| Variant : 'variety variant -> ('a, 'variety) elt| Obj : 'variety obj -> ('a, 'variety) elt| Escape : 'a escape -> ('a, _) elt| Incompatible_fields : {name : string;diff : Types.type_expr diff;} -> ('a, _) elt| Rec_occur : Types.type_expr * Types.type_expr -> ('a, _) elttype ('a, 'variety) t = ('a, 'variety) elt listtype 'variety trace = (Types.type_expr, 'variety) ttype 'variety error = (expanded_type, 'variety) tval incompatible_fields :
+ name:string ->
+ got:Types.type_expr ->
+ expected:Types.type_expr ->
+ (Types.type_expr, _) eltThe traces ('variety t) are the core error types. However, we bundle them up into three "top-level" error types, which are used elsewhere: unification_error, equality_error, and moregen_error. In the case of equality_error, this has to bundle in extra information; in general, it distinguishes the three types of errors and allows us to distinguish traces that are being built (or processed) from those that are complete and have become the final error. These error types have the invariants that their traces are nonempty; we ensure that through three smart constructors with matching names.
type equality_error = private {trace : comparison error;subst : (Types.type_expr * Types.type_expr) list;}val unification_error : trace:unification error -> unification_errorval equality_error :
+ trace:comparison error ->
+ subst:(Types.type_expr * Types.type_expr) list ->
+ equality_errorval moregen_error : trace:comparison error -> moregen_errorWraps up the two different kinds of comparison errors in one type
val swap_unification_error : unification_error -> unification_errorLift swap_trace to unification_error
module Subtype : sig ... endEventFirst-class synchronous communication.
This module implements synchronous inter-thread communications over channels. As in John Reppy's Concurrent ML system, the communication events are first-class values: they can be built and combined independently before being offered for communication.
val new_channel : unit -> 'a channelReturn a new channel.
send ch v returns the event consisting in sending the value v over the channel ch. The result value of this event is ().
receive ch returns the event consisting in receiving a value from the channel ch. The result value of this event is the value received.
val always : 'a -> 'a eventalways v returns an event that is always ready for synchronization. The result value of this event is v.
choose evl returns the event that is the alternative of all the events in the list evl.
wrap ev fn returns the event that performs the same communications as ev, then applies the post-processing function fn on the return value.
wrap_abort ev fn returns the event that performs the same communications as ev, but if it is not selected the function fn is called after the synchronization.
guard fn returns the event that, when synchronized, computes fn() and behaves as the resulting event. This enables computing events with side-effects at the time of the synchronization operation.
val sync : 'a event -> 'a'Synchronize' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed. The result value of that communication is returned.
val select : 'a event list -> 'a'Synchronize' on an alternative of events. select evl is shorthand for sync(choose evl).
val poll : 'a event -> 'a optionNon-blocking version of Event.sync: offer all the communication possibilities specified in the event to the outside world, and if one can take place immediately, perform it and return Some r where r is the result value of that communication. Otherwise, return None without blocking.
Export_id.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitExport_id.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringExport_id.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitExport_id.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tExport_idinclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create : ?name:string -> Compilation_unit.t -> tval name : t -> string optionval get_compilation_unit : t -> Compilation_unit.tExport_infoExported information (that is to say, information written into a .cmx file) about a compilation unit.
module A = Simple_value_approxtype descr = | Value_block of Tag.t * approx array| Value_mutable_block of Tag.t * int| Value_int of int| Value_char of char| Value_float of float| Value_float_array of value_float_array| Value_boxed_int : 'a A.boxed_int * 'a -> descr| Value_string of value_string| Value_closure of value_closure| Value_set_of_closures of value_set_of_closures| Value_unknown_descrand value_set_of_closures = {set_of_closures_id : Set_of_closures_id.t;bound_vars : approx Var_within_closure.Map.t;free_vars : Flambda.specialised_to Variable.Map.t;results : approx Closure_id.Map.t;aliased_symbol : Symbol.t option;}type t = private {sets_of_closures : A.function_declarations Set_of_closures_id.Map.t;Code of exported functions indexed by set of closures IDs.
*)values : descr Export_id.Map.t Compilation_unit.Map.t;Structure of exported values.
*)symbol_id : Export_id.t Symbol.Map.t;Associates symbols and values.
*)offset_fun : int Closure_id.Map.t;Positions of function pointers in their closures.
*)offset_fv : int Var_within_closure.Map.t;Positions of value pointers in their closures.
*)constant_closures : Closure_id.Set.t;invariant_params : Variable.Set.t Variable.Map.t Set_of_closures_id.Map.t;recursive : Variable.Set.t Set_of_closures_id.Map.t;}A structure that describes what a single compilation unit exports.
type transient = private {sets_of_closures : A.function_declarations Set_of_closures_id.Map.t;values : descr Export_id.Map.t Compilation_unit.Map.t;symbol_id : Export_id.t Symbol.Map.t;invariant_params : Variable.Set.t Variable.Map.t Set_of_closures_id.Map.t;recursive : Variable.Set.t Set_of_closures_id.Map.t;relevant_local_closure_ids : Closure_id.Set.t;relevant_imported_closure_ids : Closure_id.Set.t;relevant_local_vars_within_closure : Var_within_closure.Set.t;relevant_imported_vars_within_closure : Var_within_closure.Set.t;}val empty : tExport information for a compilation unit that exports nothing.
val opaque_transient :
+ compilation_unit:Compilation_unit.t ->
+ root_symbol:Symbol.t ->
+ transientval create :
+ sets_of_closures:A.function_declarations Set_of_closures_id.Map.t ->
+ values:descr Export_id.Map.t Compilation_unit.Map.t ->
+ symbol_id:Export_id.t Symbol.Map.t ->
+ offset_fun:int Closure_id.Map.t ->
+ offset_fv:int Var_within_closure.Map.t ->
+ constant_closures:Closure_id.Set.t ->
+ invariant_params:Variable.Set.t Variable.Map.t Set_of_closures_id.Map.t ->
+ recursive:Variable.Set.t Set_of_closures_id.Map.t ->
+ tCreate a new export information structure.
val create_transient :
+ sets_of_closures:A.function_declarations Set_of_closures_id.Map.t ->
+ values:descr Export_id.Map.t Compilation_unit.Map.t ->
+ symbol_id:Export_id.t Symbol.Map.t ->
+ invariant_params:Variable.Set.t Variable.Map.t Set_of_closures_id.Map.t ->
+ recursive:Variable.Set.t Set_of_closures_id.Map.t ->
+ relevant_local_closure_ids:Closure_id.Set.t ->
+ relevant_imported_closure_ids:Closure_id.Set.t ->
+ relevant_local_vars_within_closure:Var_within_closure.Set.t ->
+ relevant_imported_vars_within_closure:Var_within_closure.Set.t ->
+ transientval t_of_transient :
+ transient ->
+ program:Flambda.program ->
+ local_offset_fun:int Closure_id.Map.t ->
+ local_offset_fv:int Var_within_closure.Map.t ->
+ imported_offset_fun:int Closure_id.Map.t ->
+ imported_offset_fv:int Var_within_closure.Map.t ->
+ constant_closures:Closure_id.Set.t ->
+ tRecord information about the layout of closures and which sets of closures are constant. These are all worked out during the Flambda_to_clambda pass.
val find_description : t -> Export_id.t -> descrLook up the description of an exported value given its export ID.
val nest_eid_map :
+ 'a Export_id.Map.t ->
+ 'a Export_id.Map.t Compilation_unit.Map.tPartition a mapping from export IDs by compilation unit.
Export_info_for_packTransformations on export information that are only used for the building of packs.
val import_for_pack :
+ pack_units:Compilation_unit.Set.t ->
+ pack:Compilation_unit.t ->
+ Export_info.t ->
+ Export_info.tTransform the information from exported to be suitable to be reexported as the information for a pack named pack containing units pack_units. It mainly changes symbols of units pack_units to refer to pack instead.
Expungemodule String = Misc.Stdlib.Stringval to_keep : String.Set.t refval keep : String.Set.elt -> boolval expunge_map : Symtable.global_map -> Symtable.global_mapval expunge_crcs : (String.Set.elt * 'a) list -> (String.Set.elt * 'a) listExtract_projectionsIdentify projections from variables used in function bodies (free variables or specialised args, for example, according to which_variables below). Projections from variables that are also used boxed are not returned.
val from_function_decl :
+ env:Inline_and_simplify_aux.Env.t ->
+ which_variables:Flambda.specialised_to Variable.Map.t ->
+ function_decl:Flambda.function_declaration ->
+ Projection.Set.twhich_variables maps (existing) inner variables to (existing) outer variables in the manner of free_vars and specialised_args in Flambda.set_of_closures.
The returned projections are projecting_from (cf. projection.mli) the "existing inner vars".
Find_recursive_functions"Recursive functions" are those functions f that might call either:
f.For example in the following simultaneous definition of f g and h, f and g are recursive functions, but not h: let rec f x = g x
+ and g x = f x
+ and h x = g x
val in_function_declarations :
+ Flambda.function_declarations ->
+ backend:(module Backend_intf.S) ->
+ Variable.Set.tDetermine the recursive functions, if any, bound by the given set of function declarations. This is only intended to be used by Flambda.create_function_declarations.
Constant_defining_value.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitConstant_defining_value.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringConstant_defining_value.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitConstant_defining_value.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tFlambda.Constant_defining_valuetype t = constant_defining_valuemodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := TFlambda.With_free_variablesA module for the manipulation of terms where the recomputation of free variable sets is to be kept to a minimum.
Takes the time required to calculate the free variables of the given term (proportional to the size of the term, except that the calculation for Let is O(1)).
val create_let_reusing_defining_expr : Variable.t -> named t -> expr -> exprTakes the time required to calculate the free variables of the given expr.
val create_let_reusing_body : Variable.t -> named -> expr t -> exprTakes the time required to calculate the free variables of the given named.
val contents : 'a t -> 'aval free_variables : _ t -> Variable.Set.tO(1) time.
FlambdaIntermediate language used for tree-based analysis and optimization.
Whether the callee in a function application is known at compile time.
Simple constants. ("Structured constants" are rewritten to invocations of Pmakeblock so that they easily take part in optimizations.)
type apply = {func : Variable.t;args : Variable.t list;kind : call_kind;dbg : Debuginfo.t;inline : Lambda.inline_attribute;Instructions from the source code as to whether the callee should be inlined.
*)specialise : Lambda.specialise_attribute;Instructions from the source code as to whether the callee should be specialised.
*)}The application of a function to a list of arguments.
The update of a mutable variable. Mutable variables are distinct from immutable variables in Flambda.
type send = {kind : Lambda.meth_kind;meth : Variable.t;obj : Variable.t;args : Variable.t list;dbg : Debuginfo.t;}The invocation of a method.
type project_closure = Projection.project_closureFor details on these types, see projection.mli.
type move_within_set_of_closures = Projection.move_within_set_of_closurestype project_var = Projection.project_vartype specialised_to = {var : Variable.t;The "outer variable".
*)projection : Projection.t option;The projecting_from value (see projection.mli) of any projection must be another free variable or specialised argument (depending on whether this record type is involved in free_vars or specialised_args respectively) in the same set of closures. As such, this field describes a relation of projections between either the free_vars or the specialised_args.
}See free_vars and specialised_args, below.
type t = | Var of Variable.t| Let of let_expr| Let_mutable of let_mutable| Let_rec of (Variable.t * named) list * tCR-someday lwhite: give Let_rec the same fields as Let.
*)| Apply of apply| Send of send| Assign of assign| If_then_else of Variable.t * t * t| Switch of Variable.t * switch| String_switch of Variable.t * (string * t) list * t optionRestrictions on Lambda.Lstringswitch also apply to String_switch.
| Static_raise of Static_exception.t * Variable.t list| Static_catch of Static_exception.t * Variable.t list * t * t| Try_with of t * Variable.t * t| While of t * t| For of for_loop| Proved_unreachableFlambda terms are partitioned in a pseudo-ANF manner; many terms are required to be let-bound. This in particular ensures there is always a variable name for an expression that may be lifted out (for example if it is found to be constant). Note: All bound variables in Flambda terms must be distinct. Flambda_invariants verifies this.
and named = | Symbol of Symbol.t| Const of const| Allocated_const of Allocated_const.t| Read_mutable of Mutable_variable.t| Read_symbol_field of Symbol.t * intDuring the lifting of let bindings to program constructions after closure conversion, we generate symbols and their corresponding definitions (which may or may not be constant), together with field accesses to such symbols. We would like it to be the case that such field accesses are simplified to the relevant component of the symbol concerned. (The rationale is to generate efficient code and share constants as expected: see e.g. tests/asmcomp/staticalloc.ml.) The components of the symbol would be identified by other symbols. This sort of access pattern is feasible because the top-level structure of symbols is statically allocated and fixed at compile time. It may seem that Prim (Pfield, ...) expressions could be used to perform the field accesses. However for simplicity, to avoid having to keep track of properties of individual fields of blocks, Inconstant_idents never deems a Prim (Pfield, ...) expression to be constant. This would in general prevent field accesses to symbols from being simplified in the way we would like, since Lift_constants would not assign new symbols (i.e. the things we would like to simplify to) to the various projections from the symbols in question. To circumvent this problem we use Read_symbol_field when generating projections from the top level of symbols. Owing to the properties of symbols described above, such expressions may be eligible for declaration as constant by Inconstant_idents (and thus themselves lifted to another symbol), without any further complication. Read_symbol_field may only be used when the definition of the symbol is in scope in the program. For external unresolved symbols, Pfield may still be used; it will be changed to Read_symbol_field by Inline_and_simplify when (and if) the symbol is imported.
| Set_of_closures of set_of_closures| Project_closure of project_closure| Move_within_set_of_closures of move_within_set_of_closures| Project_var of project_var| Prim of Clambda_primitives.primitive * Variable.t list * Debuginfo.t| Expr of tANF escape hatch.
*)Values of type named will always be let-bound to a Variable.t.
and let_expr = private {var : Variable.t;defining_expr : named;body : t;free_vars_of_defining_expr : Variable.Set.t;A cache of the free variables in the defining expression of the let.
free_vars_of_body : Variable.Set.t;A cache of the free variables of the body of the let. This is an important optimization.
}and let_mutable = {var : Mutable_variable.t;initial_value : Variable.t;contents_kind : Lambda.value_kind;body : t;}and set_of_closures = private {function_decls : function_declarations;free_vars : specialised_to Variable.Map.t;Mapping from all variables free in the body of the function_decls to variables in scope at the definition point of the set_of_closures. The domain of this map is sometimes known as the "variables bound by the closure".
specialised_args : specialised_to Variable.Map.t;Parameters whose corresponding arguments are known to always alias a particular value. These are the only parameters that may, during Inline_and_simplify, have non-unknown approximations.
An argument may only be specialised to a variable in the scope of the corresponding set of closures declaration. Usually, that variable itself also appears in the position of the specialised argument at all call sites of the function. However it may also be the case (for example in code generated as a result of Augment_specialised_args) that the various call sites of such a function have differing variables in the position of the specialised argument. This is permissible *so long as it is certain they all alias the same value*. Great care must be taken in transformations that result in this situation since there are no invariant checks for correctness.
As an example, supposing all call sites of f are represented here: let x = ... in
+ let f a b c = ... in
+ let y = ... in
+ f x y 1;
+ f x y 1 the specialised arguments of f can (but does not necessarily) contain the association a -> x, but cannot contain b -> y because f is not in the scope of y. If f were the recursive function let rec f a b c = f a 1 2 in, a -> x would still be a valid specialised argument because all recursive calls maintain the invariant.
This information is used for optimization purposes, if such a binding is known, it is possible to specialise the body of the function according to its parameter. This is usually introduced when specialising a recursive function, for instance. let rec map f = function
+ | [] -> []
+ | h :: t -> f h :: map f t
+ let map_succ l =
+ let succ x = x + 1 in
+ map succ l map can be duplicated in map_succ to be specialised for the argument f. This will result in let map_succ l =
+ let succ x = x + 1 in
+ let rec map f = function
+ | [] -> []
+ | h :: t -> f h :: map f t in
+ map succ l with map having f -> succ in its specialised_args field.
Specialised argument information for arguments that are used must never be erased. This ensures that specialised arguments whose approximations describe closures maintain those approximations, which is essential to transport the closure freshening information to the point of use (e.g. a Project_var from such an argument).
direct_call_surrogates : Variable.t Variable.Map.t;If direct_call_surrogates maps fun_var1 to fun_var2 then direct calls to fun_var1 should be redirected to fun_var2. This is used to reduce the overhead of transformations that introduce wrapper functions (which will be inlined at direct call sites, but will penalise indirect call sites). direct_call_surrogates may not be transitively closed.
}The representation of a set of function declarations (possibly mutually recursive). Such a set encapsulates the declarations themselves, information about their defining environment, and information used specifically for optimization. Before a function can be applied it must be "projected" from a set of closures to yield a "closure". This is done using Project_closure (see above). Given a closure, not only can it be applied, but information about its defining environment can be retrieved (using Project_var, see above). At runtime, a set_of_closures corresponds to an OCaml value with tag Closure_tag (possibly with inline Infix_tag(s)). As an optimization, an operation (Move_within_set_of_closures) is provided (see above) which enables one closure within a set to be located given another closure in the same set. This avoids keeping a pointer to the whole set of closures alive when compiling, for example, mutually-recursive functions.
and function_declarations = private {is_classic_mode : bool;Indicates whether this function_declarations was compiled with -Oclassic.
set_of_closures_id : Set_of_closures_id.t;An identifier (unique across all Flambda trees currently in memory) of the set of closures associated with this set of function declarations.
*)set_of_closures_origin : Set_of_closures_origin.t;An identifier of the original set of closures on which this set of function declarations is based. Used to prevent different specialisations of the same functions from being inlined/specialised within each other.
*)funs : function_declaration Variable.Map.t;The function(s) defined by the set of function declarations. The keys of this map are often referred to in the code as "fun_var"s.
*)}and function_declaration = private {closure_origin : Closure_origin.t;params : Parameter.t list;body : t;free_variables : Variable.Set.t;All variables free in the *body* of the function. For example, a variable that is bound as one of the function's parameters will still be included in this set. This field is present as an optimization.
*)free_symbols : Symbol.Set.t;All symbols that occur in the function's body. (Symbols can never be bound in a function's body; the only thing that binds symbols is the program constructions below.)
stub : bool;A stub function is a generated function used to prepare arguments or return values to allow indirect calls to functions with a special calling convention. For instance indirect calls to tuplified functions must go through a stub. Stubs will be unconditionally inlined.
*)dbg : Debuginfo.t;Debug info for the function declaration.
*)inline : Lambda.inline_attribute;Inlining requirements from the source code.
*)specialise : Lambda.specialise_attribute;Specialising requirements from the source code.
*)is_a_functor : bool;Whether the function is known definitively to be a functor.
*)poll : Lambda.poll_attribute;Behaviour for polls
*)}and switch = {numconsts : Numbers.Int.Set.t;Integer cases
*)consts : (int * t) list;Integer cases
*)numblocks : Numbers.Int.Set.t;Number of tag block cases
*)blocks : (int * t) list;Tag block cases
*)failaction : t option;Action to take if none matched
*)}Equivalent to the similar type in Lambda.
and for_loop = {bound_var : Variable.t;from_value : Variable.t;to_value : Variable.t;direction : Asttypes.direction_flag;body : t;}Equivalent to the similar type in Lambda.
and constant_defining_value = | Allocated_const of Allocated_const.tA single constant. These are never "simple constants" (type const) but instead more complicated constructions.
| Block of Tag.t * constant_defining_value_block_field listA pre-allocated block full of constants (either simple constants or references to other constants, see below).
*)| Set_of_closures of set_of_closuresA closed (and thus constant) set of closures. (That is to say, free_vars must be empty.)
| Project_closure of Symbol.t * Closure_id.tSelection of one closure from a constant set of closures. Analogous to the equivalent operation on expressions.
*)Like a subset of Flambda.named, except that instead of Variable.ts we have Symbol.ts, and everything is a constant (i.e. with a fixed value known at compile time). Values of this type describe constants that will be directly assigned to symbols in the object file (see below).
module Constant_defining_value :
+ Identifiable.S with type t = constant_defining_valuetype expr = ttype program_body = | Let_symbol of Symbol.t * constant_defining_value * program_bodyDefine the given symbol to have the given constant value.
*)| Let_rec_symbol of (Symbol.t * constant_defining_value) list * program_bodyAs for Let_symbol, but recursive. This is needed to treat examples like this, where a constant set of closures is lifted to toplevel:
let rec f x = f x
After lifting this produces (in pseudo-Flambda):
Let_rec_symbol set_of_closures_symbol = (Set_of_closures f x ->
+ let applied_function = Symbol f_closure in
+ Apply (applied_function, x) ) and f_closure = Project_closure (set_of_closures_symbol, f)
Use of Let_rec_symbol, by virtue of the special handling in Inline_and_simplify.define_let_rec_symbol_approx, enables the approximation of the set of closures to be present in order to correctly simplify the Project_closure construction. (See Inline_and_simplify.simplify_project_closure for that part.)
| Initialize_symbol of Symbol.t * Tag.t * t list * program_bodyDefine the given symbol as a constant block of the given size and tag; but with a possibly non-constant initializer. The initializer will be executed at most once (from the entry point of the compilation unit).
*)| Effect of t * program_bodyCause the given expression, which may have a side effect, to be executed. The resulting value is discarded. Effect constructions are never re-ordered.
| End of Symbol.tEnd accepts the root symbol: the only symbol that can never be eliminated.
A "program" is the contents of one compilation unit. It describes the various values that are assigned to symbols (and in some cases fields of such symbols) in the object file. As such, it is closely related to the compilation of toplevel modules.
val free_variables :
+ ?ignore_uses_as_callee:unit ->
+ ?ignore_uses_as_argument:unit ->
+ ?ignore_uses_in_project_var:unit ->
+ t ->
+ Variable.Set.tCompute the free variables of a term. (This is O(1) for Lets). If ignore_uses_as_callee, all free variables inside Apply expressions are ignored. Likewise ignore_uses_in_project_var for Project_var expressions.
val free_variables_named :
+ ?ignore_uses_in_project_var:unit ->
+ named ->
+ Variable.Set.tCompute the free variables of a named expression.
val used_variables :
+ ?ignore_uses_as_callee:unit ->
+ ?ignore_uses_as_argument:unit ->
+ ?ignore_uses_in_project_var:unit ->
+ t ->
+ Variable.Set.tCompute _all_ variables occurring inside an expression.
val used_variables_named :
+ ?ignore_uses_in_project_var:unit ->
+ named ->
+ Variable.Set.tCompute _all_ variables occurring inside a named expression.
val free_symbols : expr -> Symbol.Set.tval free_symbols_named : named -> Symbol.Set.tval free_symbols_program : program -> Symbol.Set.tval fold_lets_option :
+ t ->
+ init:'a ->
+ for_defining_expr:('a -> Variable.t -> named -> 'a * Variable.t * named) ->
+ for_last_body:('a -> t -> t * 'b) ->
+ filter_defining_expr:
+ ('b ->
+ Variable.t ->
+ named ->
+ Variable.Set.t ->
+ 'b * Variable.t * named option) ->
+ t * 'bUsed to avoid exceeding the stack limit when handling expressions with multiple consecutive nested Let-expressions. This saves rewriting large simplification functions in CPS. This function provides for the rewriting or elimination of expressions during the fold.
val map_lets :
+ t ->
+ for_defining_expr:(Variable.t -> named -> named) ->
+ for_last_body:(t -> t) ->
+ after_rebuild:(t -> t) ->
+ tLike fold_lets_option, but just a map.
val iter_lets :
+ t ->
+ for_defining_expr:(Variable.t -> named -> unit) ->
+ for_last_body:(t -> unit) ->
+ for_each_let:(t -> unit) ->
+ unitLike map_lets, but just an iterator.
val create_let : Variable.t -> named -> t -> tCreates a Let expression. (This computes the free variables of the defining expression and the body.)
Apply the specified function f to the defining expression of the given Let-expression, returning a new Let.
module With_free_variables : sig ... endA module for the manipulation of terms where the recomputation of free variable sets is to be kept to a minimum.
val create_function_declaration :
+ params:Parameter.t list ->
+ body:t ->
+ stub:bool ->
+ dbg:Debuginfo.t ->
+ inline:Lambda.inline_attribute ->
+ specialise:Lambda.specialise_attribute ->
+ is_a_functor:bool ->
+ closure_origin:Closure_origin.t ->
+ poll:Lambda.poll_attribute ->
+ function_declarationCreate a function declaration. This calculates the free variables and symbols occurring in the specified body.
val update_function_declaration :
+ function_declaration ->
+ params:Parameter.t list ->
+ body:t ->
+ function_declarationCreate a function declaration based on another function declaration
val create_function_declarations :
+ is_classic_mode:bool ->
+ funs:function_declaration Variable.Map.t ->
+ function_declarationsCreate a set of function declarations given the individual declarations.
val create_function_declarations_with_origin :
+ is_classic_mode:bool ->
+ funs:function_declaration Variable.Map.t ->
+ set_of_closures_origin:Set_of_closures_origin.t ->
+ function_declarationsCreate a set of function declarations with a given set of closures origin.
val update_body_of_function_declaration :
+ function_declaration ->
+ body:expr ->
+ function_declarationChange only the code of a function declaration.
val update_function_decl's_params_and_body :
+ function_declaration ->
+ params:Parameter.t list ->
+ body:expr ->
+ function_declarationChange only the code and parameters of a function declaration.
val update_function_declarations :
+ function_declarations ->
+ funs:function_declaration Variable.Map.t ->
+ function_declarationsCreate a set of function declarations based on another set of function declarations.
val create_function_declarations_with_closures_origin :
+ is_classic_mode:bool ->
+ funs:function_declaration Variable.Map.t ->
+ set_of_closures_origin:Set_of_closures_origin.t ->
+ function_declarationsval import_function_declarations_for_pack :
+ function_declarations ->
+ (Set_of_closures_id.t -> Set_of_closures_id.t) ->
+ (Set_of_closures_origin.t -> Set_of_closures_origin.t) ->
+ function_declarationsval create_set_of_closures :
+ function_decls:function_declarations ->
+ free_vars:specialised_to Variable.Map.t ->
+ specialised_args:specialised_to Variable.Map.t ->
+ direct_call_surrogates:Variable.t Variable.Map.t ->
+ set_of_closuresCreate a set of closures. Checks are made to ensure that free_vars and specialised_args are reasonable.
val used_params : function_declaration -> Variable.Set.tGiven a function declaration, find which of its parameters (if any) are used in the body.
val iter_general :
+ toplevel:bool ->
+ (t -> unit) ->
+ (named -> unit) ->
+ maybe_named ->
+ unitThis function is designed for the internal use of Flambda_iterators. See that module for iterators to be used over Flambda terms.
val print : Stdlib.Format.formatter -> t -> unitval print_named : Stdlib.Format.formatter -> named -> unitval print_program : Stdlib.Format.formatter -> program -> unitval print_const : Stdlib.Format.formatter -> const -> unitval print_constant_defining_value :
+ Stdlib.Format.formatter ->
+ constant_defining_value ->
+ unitval print_function_declaration :
+ Stdlib.Format.formatter ->
+ (Variable.t * function_declaration) ->
+ unitval print_function_declarations :
+ Stdlib.Format.formatter ->
+ function_declarations ->
+ unitval print_project_closure : Stdlib.Format.formatter -> project_closure -> unitval print_move_within_set_of_closures :
+ Stdlib.Format.formatter ->
+ move_within_set_of_closures ->
+ unitval print_project_var : Stdlib.Format.formatter -> project_var -> unitval print_set_of_closures : Stdlib.Format.formatter -> set_of_closures -> unitval print_specialised_to : Stdlib.Format.formatter -> specialised_to -> unitval equal_specialised_to : specialised_to -> specialised_to -> boolval compare_project_var : project_var -> project_var -> intval compare_move_within_set_of_closures :
+ move_within_set_of_closures ->
+ move_within_set_of_closures ->
+ intval compare_project_closure : project_closure -> project_closure -> intFlambda_invariantsval check_exn : ?kind:flambda_kind -> Flambda.program -> unitChecking of invariants on Flambda expressions. Raises an exception if a check fails.
Flambda_iteratorsval apply_on_subexpressions :
+ (Flambda.t -> unit) ->
+ (Flambda.named -> unit) ->
+ Flambda.t ->
+ unitApply the given functions to the immediate subexpressions of the given Flambda expression. For avoidance of doubt, if a subexpression is Expr, it is passed to the function taking Flambda.named, rather than being followed and passed to the function taking Flambda.t.
val map_subexpressions :
+ (Flambda.t -> Flambda.t) ->
+ (Variable.t -> Flambda.named -> Flambda.named) ->
+ Flambda.t ->
+ Flambda.tval iter : (Flambda.t -> unit) -> (Flambda.named -> unit) -> Flambda.t -> unitval iter_on_named :
+ (Flambda.t -> unit) ->
+ (Flambda.named -> unit) ->
+ Flambda.named ->
+ unitval iter_named : (Flambda.named -> unit) -> Flambda.t -> unitval iter_named_on_named : (Flambda.named -> unit) -> Flambda.named -> unitval iter_toplevel :
+ (Flambda.t -> unit) ->
+ (Flambda.named -> unit) ->
+ Flambda.t ->
+ unititer_toplevel f t applies f on every toplevel subexpression of t. In particular, it never applies f to the body of a function (which will always be contained within an Set_of_closures expression).
val iter_named_toplevel :
+ (Flambda.t -> unit) ->
+ (Flambda.named -> unit) ->
+ Flambda.named ->
+ unitval iter_on_sets_of_closures :
+ (Flambda.set_of_closures -> unit) ->
+ Flambda.t ->
+ unitval iter_on_set_of_closures_of_program :
+ Flambda.program ->
+ f:(constant:bool -> Flambda.set_of_closures -> unit) ->
+ unitval iter_all_immutable_let_and_let_rec_bindings :
+ Flambda.t ->
+ f:(Variable.t -> Flambda.named -> unit) ->
+ unitval iter_all_toplevel_immutable_let_and_let_rec_bindings :
+ Flambda.t ->
+ f:(Variable.t -> Flambda.named -> unit) ->
+ unitval iter_exprs_at_toplevel_of_program :
+ Flambda.program ->
+ f:(Flambda.t -> unit) ->
+ unitval iter_named_of_program :
+ Flambda.program ->
+ f:(Flambda.named -> unit) ->
+ unitval iter_constant_defining_values_on_program :
+ Flambda.program ->
+ f:(Flambda.constant_defining_value -> unit) ->
+ unitval iter_apply_on_program :
+ Flambda.program ->
+ f:(Flambda.apply -> unit) ->
+ unitval map :
+ (Flambda.t -> Flambda.t) ->
+ (Flambda.named -> Flambda.named) ->
+ Flambda.t ->
+ Flambda.tval map_named : (Flambda.named -> Flambda.named) -> Flambda.t -> Flambda.tval map_toplevel :
+ (Flambda.t -> Flambda.t) ->
+ (Flambda.named -> Flambda.named) ->
+ Flambda.t ->
+ Flambda.tval map_toplevel_named :
+ (Flambda.named -> Flambda.named) ->
+ Flambda.t ->
+ Flambda.tval map_symbols_on_set_of_closures :
+ Flambda.set_of_closures ->
+ f:(Symbol.t -> Symbol.t) ->
+ Flambda.set_of_closuresval map_toplevel_sets_of_closures :
+ Flambda.t ->
+ f:(Flambda.set_of_closures -> Flambda.set_of_closures) ->
+ Flambda.tval map_apply : Flambda.t -> f:(Flambda.apply -> Flambda.apply) -> Flambda.tval map_function_bodies :
+ Flambda.set_of_closures ->
+ f:(Flambda.t -> Flambda.t) ->
+ Flambda.set_of_closuresval map_sets_of_closures :
+ Flambda.t ->
+ f:(Flambda.set_of_closures -> Flambda.set_of_closures) ->
+ Flambda.tval map_sets_of_closures_of_program :
+ Flambda.program ->
+ f:(Flambda.set_of_closures -> Flambda.set_of_closures) ->
+ Flambda.programval map_project_var_to_expr_opt :
+ Flambda.t ->
+ f:(Flambda.project_var -> Flambda.t option) ->
+ Flambda.tval map_project_var_to_named_opt :
+ Flambda.t ->
+ f:(Flambda.project_var -> Flambda.named option) ->
+ Flambda.tval map_exprs_at_toplevel_of_program :
+ Flambda.program ->
+ f:(Flambda.t -> Flambda.t) ->
+ Flambda.programval map_named_of_program :
+ Flambda.program ->
+ f:(Variable.t -> Flambda.named -> Flambda.named) ->
+ Flambda.programval map_all_immutable_let_and_let_rec_bindings :
+ Flambda.t ->
+ f:(Variable.t -> Flambda.named -> Flambda.named) ->
+ Flambda.tval fold_function_decls_ignoring_stubs :
+ Flambda.set_of_closures ->
+ init:'a ->
+ f:
+ (fun_var:Variable.t ->
+ function_decl:Flambda.function_declaration ->
+ 'a ->
+ 'a) ->
+ 'aFlambda_middle_endTranslate Lambda code to Flambda code, optimize it, and produce Clambda.
val lambda_to_clambda :
+ backend:(module Backend_intf.S) ->
+ prefixname:string ->
+ ppf_dump:Stdlib.Format.formatter ->
+ Lambda.program ->
+ Clambda.with_constantsFlambda_to_clambdatype result = {expr : Clambda.ulambda;preallocated_blocks : Clambda.preallocated_block list;structured_constants : Clambda.ustructured_constant Symbol.Map.t;exported : Export_info.t;}val convert :
+ ppf_dump:Stdlib.Format.formatter ->
+ (Flambda.program * Export_info.transient) ->
+ resultConvert an Flambda program, with associated proto-export information, to Clambda. This yields a Clambda expression together with augmented export information and details about required statically-allocated values (preallocated blocks, for Initialize_symbol, and structured constants).
It is during this process that accesses to variables within closures are transformed to field accesses within closure values. For direct calls, the hidden closure parameter is added. Switch tables are also built.
Flambda_utils.Switch_storerFor the compilation of switch statements.
val mk_store : unit -> (Flambda.t, unit) Switch.t_storeFlambda_utilsUtility functions for the Flambda intermediate language.
Access functions
val find_declaration :
+ Closure_id.t ->
+ Flambda.function_declarations ->
+ Flambda.function_declarationfind_declaration f decl raises Not_found if f is not in decl.
val find_declaration_variable :
+ Closure_id.t ->
+ Flambda.function_declarations ->
+ Variable.tfind_declaration_variable f decl raises Not_found if f is not in decl.
val find_free_variable :
+ Var_within_closure.t ->
+ Flambda.set_of_closures ->
+ Variable.tfind_free_variable v clos raises Not_found if c is not in clos.
Utility functions
val function_arity : Flambda.function_declaration -> intval variables_bound_by_the_closure :
+ Closure_id.t ->
+ Flambda.function_declarations ->
+ Variable.Set.tVariables "bound by a closure" are those variables free in the corresponding function's body that are neither:
let binding that introduces the function declaration(s). In particular, if f, g and h are being introduced by a simultaneous, possibly mutually-recursive let binding then none of f, g or h are bound in any of the closures for f, g and h.If can_be_merged f1 f2 is true, it is safe to merge switch branches containing f1 and f2.
val description_of_toplevel_node : Flambda.t -> stringval make_closure_declaration :
+ is_classic_mode:bool ->
+ id:Variable.t ->
+ body:Flambda.t ->
+ params:Parameter.t list ->
+ Flambda.tval toplevel_substitution :
+ Variable.t Variable.Map.t ->
+ Flambda.expr ->
+ Flambda.exprval toplevel_substitution_named :
+ Variable.t Variable.Map.t ->
+ Flambda.named ->
+ Flambda.namedval bind :
+ bindings:(Variable.t * Flambda.named) list ->
+ body:Flambda.t ->
+ Flambda.tbind [var1, expr1; ...; varN, exprN] body binds using Immutable Let expressions the given (var, expr) pairs around the body.
val name_expr : name:Internal_variable_names.t -> Flambda.named -> Flambda.tval name_expr_from_var : var:Variable.t -> Flambda.named -> Flambda.tval initialize_symbols :
+ Flambda.program ->
+ (Symbol.t * Tag.t * Flambda.t list) listval imported_symbols : Flambda.program -> Symbol.Set.tval needed_import_symbols : Flambda.program -> Symbol.Set.tval introduce_needed_import_symbols : Flambda.program -> Flambda.programval root_symbol : Flambda.program -> Symbol.tval might_raise_static_exn : Flambda.named -> Static_exception.t -> boolReturns true iff the given term might raise the given static exception.
val make_closure_map : Flambda.program -> Set_of_closures_id.t Closure_id.Map.tCreates a map from closure IDs to set_of_closure IDs by iterating over all sets of closures in the given program.
val all_lifted_constants :
+ Flambda.program ->
+ (Symbol.t * Flambda.constant_defining_value) listThe definitions of all constants that have been lifted out to Let_symbol or Let_rec_symbol constructions.
val all_lifted_constants_as_map :
+ Flambda.program ->
+ Flambda.constant_defining_value Symbol.Map.tLike all_lifted_constant_symbols, but returns a map instead of a list.
val all_lifted_constant_sets_of_closures :
+ Flambda.program ->
+ Set_of_closures_id.Set.tThe identifiers of all constant sets of closures that have been lifted out to Let_symbol or Let_rec_symbol constructions.
val all_lifted_constant_closures : Flambda.program -> Closure_id.Set.tval all_sets_of_closures : Flambda.program -> Flambda.set_of_closures listAll sets of closures in the given program (whether or not bound to a symbol.)
val all_sets_of_closures_map :
+ Flambda.program ->
+ Flambda.set_of_closures Set_of_closures_id.Map.tval substitute_read_symbol_field_for_variables :
+ (Symbol.t * int list) Variable.Map.t ->
+ Flambda.t ->
+ Flambda.tmodule Switch_storer : sig ... endFor the compilation of switch statements.
val fun_vars_referenced_in_decls :
+ Flambda.function_declarations ->
+ closure_symbol:(Closure_id.t -> Symbol.t) ->
+ Variable.Set.t Variable.Map.tWithin a set of function declarations there is a set of function bodies, each of which may (or may not) reference one of the other functions in the same set. Initially such intra-set references are by Vars (known as "fun_var"s) but if the function is lifted by Lift_constants then the references will be translated to Symbols. This means that optimization passes that need to identify whether a given "fun_var" (i.e. a key in the funs map in a value of type function_declarations) is used in one of the function bodies need to examine the free_symbols as well as the free_variables members of function_declarations. This function makes that process easier by computing all used "fun_var"s in the bodies of the given set of function declarations, including the cases where the references are Symbols. The returned value is a map from "fun_var"s to the "fun_var"s (if any) used in the body of the function associated with that "fun_var".
val closures_required_by_entry_point :
+ entry_point:Closure_id.t ->
+ closure_symbol:(Closure_id.t -> Symbol.t) ->
+ Flambda.function_declarations ->
+ Variable.Set.tComputes the set of closure_id in the set of closures that are required used (transitively) the entry_point
val all_functions_parameters : Flambda.function_declarations -> Variable.Set.tval all_free_symbols : Flambda.function_declarations -> Symbol.Set.tval contains_stub : Flambda.function_declarations -> boolval clean_projections :
+ which_variables:Flambda.specialised_to Variable.Map.t ->
+ Flambda.specialised_to Variable.Map.tval projection_to_named : Projection.t -> Flambda.namedval parameters_specialised_to_the_same_variable :
+ function_decls:Flambda.function_declarations ->
+ specialised_args:Flambda.specialised_to Variable.Map.t ->
+ specialised_to_same_as list Variable.Map.tFor each parameter in a given set of function declarations and the usual specialised-args mapping, determine which other parameters are specialised to the same variable as that parameter. The result is presented as a map from fun_vars to lists, corresponding componentwise to the usual params list in the corresponding function declaration.
Freshening.Project_varA table used for freshening of identifiers in Project_closure and Move_within_set_of_closures ("ids of closures"); and Project_var ("bound vars of closures") expressions.
This information is propagated bottom up and populated when inlining a function containing a closure declaration.
For instance, let f x =
+ let g y = ... x ... in
+ ... g.x ... (Project_var x)
+ ... g 1 ... (Apply (Project_closure g ...))
+
If f is inlined, g is renamed. The approximation of g will carry this table such that later the access to the field x of g and selection of g in the closure can be substituted.
val empty : tval apply_closure_id : t -> Closure_id.t -> Closure_id.tFreshen a closure ID based on the given renaming. The same ID is returned if the renaming does not affect it. If dealing with approximations, you probably want to use Simple_value_approx.freshen_and_check_closure_id instead of this function.
val apply_var_within_closure :
+ t ->
+ Var_within_closure.t ->
+ Var_within_closure.tLike apply_closure_id, but for variables within closures.
val print : Stdlib.Format.formatter -> t -> unitFresheningFreshening of various identifiers.
type subst = tval empty : tThe freshening that does nothing. This is the unique inactive freshening.
val is_empty : t -> boolActivate the freshening. Without activation, operations to request freshenings have no effect (cf. the documentation below for add_variable). As such, the inactive renaming is unique.
Given the inactive freshening, return the same; otherwise, return an empty active freshening.
val add_variable : t -> Variable.t -> Variable.t * tadd_variable t var If t is active: It returns a fresh variable new_var and adds var -> new_var to the freshening. If a renaming other_var -> var or symbol -> var was already present in t, it will also add other_var -> new_var and symbol -> new_var. If t is inactive, this is the identity.
val add_variables' : t -> Variable.t list -> Variable.t list * tLike add_variable, but for multiple variables, each freshened separately.
val add_variables : t -> (Variable.t * 'a) list -> (Variable.t * 'a) list * tLike add_variables', but passes through the second component of the input list unchanged.
val add_mutable_variable : t -> Mutable_variable.t -> Mutable_variable.t * tLike add_variable, but for mutable variables.
val add_static_exception : t -> Static_exception.t -> Static_exception.t * tAs for add_variable, but for static exception identifiers.
val apply_variable : t -> Variable.t -> Variable.tapply_variable t var applies the freshening t to var. If no renaming is specified in t for var it is returned unchanged.
val apply_mutable_variable : t -> Mutable_variable.t -> Mutable_variable.tAs for apply_variable, but for mutable variables.
val apply_static_exception : t -> Static_exception.t -> Static_exception.tAs for apply_variable, but for static exception identifiers.
val rewrite_recursive_calls_with_symbols :
+ t ->
+ Flambda.function_declarations ->
+ make_closure_symbol:(Closure_id.t -> Symbol.t) ->
+ Flambda.function_declarationsReplace recursive accesses to the closures in the set through Symbol by the corresponding Var. This is used to recover the recursive call when importing code from another compilation unit.
If the renaming is inactive, this is the identity.
module Project_var : sig ... endval apply_function_decls_and_free_vars :
+ t ->
+ (Flambda.specialised_to * 'a) Variable.Map.t ->
+ Flambda.function_declarations ->
+ only_freshen_parameters:bool ->
+ (Flambda.specialised_to * 'a) Variable.Map.t
+ * Flambda.function_declarations
+ * t
+ * Project_var.tval does_not_freshen : t -> Variable.t list -> boolval print : Stdlib.Format.formatter -> t -> unitval freshen_projection_relation :
+ Flambda.specialised_to Variable.Map.t ->
+ freshening:t ->
+ closure_freshening:Project_var.t ->
+ Flambda.specialised_to Variable.Map.tN.B. This does not freshen the domain of the supplied map, only the range.
val freshen_projection_relation' :
+ (Flambda.specialised_to * 'a) Variable.Map.t ->
+ freshening:t ->
+ closure_freshening:Project_var.t ->
+ (Flambda.specialised_to * 'a) Variable.Map.tMake.Oval repr : 'a -> tval obj : t -> 'aval is_block : t -> boolval tag : t -> intval size : t -> intval double_field : t -> int -> floatMake._type valu = O.tval eval_address : Env.address -> valuGenprintval.Maketype t = O.tval install_printer :
+ Path.t ->
+ Types.type_expr ->
+ (Stdlib.Format.formatter -> t -> unit) ->
+ unitval install_generic_printer :
+ Path.t ->
+ Path.t ->
+ (int ->
+ (int -> t -> Outcometree.out_value, t -> Outcometree.out_value) gen_printer) ->
+ unitval install_generic_printer' :
+ Path.t ->
+ Path.t ->
+ (Stdlib.Format.formatter -> t -> unit, Stdlib.Format.formatter -> t -> unit)
+ gen_printer ->
+ unitinstall_generic_printer' function_path constructor_path printer function_path is used to remove the printer.
val remove_printer : Path.t -> unitval outval_of_untyped_exception : t -> Outcometree.out_valueval outval_of_value :
+ int ->
+ int ->
+ (int -> t -> Types.type_expr -> Outcometree.out_value option) ->
+ Env.t ->
+ t ->
+ Types.type_expr ->
+ Outcometree.out_valueGenprintvalGenprintval.EVALPATHGenprintval.OBJval repr : 'a -> tval obj : t -> 'aval is_block : t -> boolval tag : t -> intval size : t -> intval double_field : t -> int -> floatGenprintval.Sval install_printer :
+ Path.t ->
+ Types.type_expr ->
+ (Stdlib.Format.formatter -> t -> unit) ->
+ unitval install_generic_printer :
+ Path.t ->
+ Path.t ->
+ (int ->
+ (int -> t -> Outcometree.out_value, t -> Outcometree.out_value) gen_printer) ->
+ unitval install_generic_printer' :
+ Path.t ->
+ Path.t ->
+ (Stdlib.Format.formatter -> t -> unit, Stdlib.Format.formatter -> t -> unit)
+ gen_printer ->
+ unitinstall_generic_printer' function_path constructor_path printer function_path is used to remove the printer.
val remove_printer : Path.t -> unitval outval_of_untyped_exception : t -> Outcometree.out_valueval outval_of_value :
+ int ->
+ int ->
+ (int -> t -> Types.type_expr -> Outcometree.out_value option) ->
+ Env.t ->
+ t ->
+ Types.type_expr ->
+ Outcometree.out_valueId_types.IdUnitId._val create : ?name:string -> unit -> tUnitId.Compilation_unitinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitId_types.UnitIdmodule Compilation_unit : Identifiable.Thingval create : ?name:string -> Compilation_unit.t -> tval unit : t -> Compilation_unit.tId_typesmodule type BaseId = sig ... endGeneric identifier type
module type Id = sig ... endmodule type UnitId = sig ... endFully qualified identifiers
module UnitId
+ (_ : Id)
+ (Compilation_unit : Identifiable.Thing) :
+ UnitId with module Compilation_unit := Compilation_unitId_types.BaseIdGeneric identifier type
val hash : t -> intval name : t -> string optionval to_string : t -> stringval output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitId_types.Idval create : ?name:string -> unit -> tUnitId.Compilation_unitinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitId_types.UnitIdFully qualified identifiers
module Compilation_unit : Identifiable.Thingval create : ?name:string -> Compilation_unit.t -> tval unit : t -> Compilation_unit.tIdent.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitIdent.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringIdent.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitIdent.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tIdentinclude Identifiable.S with type t := tmodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tval output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval print_with_scope : Stdlib.Format.formatter -> t -> unitSame as print except that it will also add a "n" suffix if the scope of the argument is n.
val create_scoped : scope:int -> string -> tval create_local : string -> tval create_persistent : string -> tval create_predef : string -> tCreates an identifier with the same name as the input, a fresh stamp, and no scope.
val name : t -> stringval unique_name : t -> stringval unique_toplevel_name : t -> stringval persistent : t -> boolCompare identifiers by binding location. Two identifiers are the same either if they are both non-persistent and have been created by the same call to create_*, or if they are both persistent and have the same name.
val global : t -> boolval is_predef : t -> boolval scope : t -> intval empty : 'a tblMake.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitMake.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringMake.Ttype t = T.tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitMake.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tMake.Tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitIdentifiable.Makeinclude Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitPair.Ainclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitPair.Binclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitIdentifiable.Pairinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitIdentifiableUniform interface for common data structures over various things.
Warning: this module is unstable and part of compiler-libs.
module type Thing = sig ... endmodule type Set = sig ... endmodule type Map = sig ... endmodule type Tbl = sig ... endmodule type S = sig ... endMap.TA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Identifiable.Mapmodule T : Stdlib.Map.OrderedTypeinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitS.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitS.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringS.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitS.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tIdentifiable.Sinclude Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitSet.TA total ordering function over the set elements. This is a two-argument function f such that f e1 e2 is zero if the elements e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Identifiable.Setmodule T : Stdlib.Set.OrderedTypeinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringTbl.Tinclude Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
include Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Identifiable.Tblmodule T : sig ... endinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tIdentifiable.Thinginclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitImport_approxCreate simple value approximations from the export information in .cmx files.
val really_import : Simple_value_approx.descr -> Simple_value_approx.descrGiven an approximation description, load .cmx files (possibly more than one) until the description is fully resolved. If a necessary .cmx file cannot be found, "unresolved" will be returned.
val really_import_approx : Simple_value_approx.t -> Simple_value_approx.tMaps the description of the given approximation through really_import.
val import_symbol : Symbol.t -> Simple_value_approx.tRead and convert the approximation of a given symbol from the relevant .cmx file. Unlike the "really_" functions, this does not continue to load .cmx files until the approximation is fully resolved.
Includeclassval class_types :
+ Env.t ->
+ Types.class_type ->
+ Types.class_type ->
+ Ctype.class_match_failure listval class_type_declarations :
+ loc:Location.t ->
+ Env.t ->
+ Types.class_type_declaration ->
+ Types.class_type_declaration ->
+ Ctype.class_match_failure listval class_declarations :
+ Env.t ->
+ Types.class_declaration ->
+ Types.class_declaration ->
+ Ctype.class_match_failure listval report_error :
+ Printtyp.type_or_scheme ->
+ Stdlib.Format.formatter ->
+ Ctype.class_match_failure list ->
+ unitIncludecoretype primitive_mismatch = | Name| Arity| No_alloc of position| Native_name| Result_repr| Argument_repr of inttype value_mismatch = | Primitive_mismatch of primitive_mismatch| Not_a_primitive| Type of Errortrace.moregen_errorexception Dont_match of value_mismatchtype record_change =
+ (Types.label_declaration as 'ld, 'ld, label_mismatch)
+ Diffing_with_keys.changetype record_mismatch = | Label_mismatch of record_change list| Unboxed_float_representation of positiontype constructor_mismatch = | Type of Errortrace.equality_error| Arity| Inline_record of record_change list| Kind of position| Explicit_return_type of positiontype extension_constructor_mismatch = | Constructor_privacy| Constructor_mismatch of Ident.t
+ * Types.extension_constructor
+ * Types.extension_constructor
+ * constructor_mismatchtype variant_change =
+ (Types.constructor_declaration as 'cd, 'cd, constructor_mismatch)
+ Diffing_with_keys.changetype private_variant_mismatch = | Only_outer_closed| Missing of position * string| Presence of string| Incompatible_types_for of string| Types of Errortrace.equality_errortype type_mismatch = | Arity| Privacy of privacy_mismatch| Kind| Constraint of Errortrace.equality_error| Manifest of Errortrace.equality_error| Private_variant of Types.type_expr * Types.type_expr * private_variant_mismatch| Private_object of Types.type_expr * Types.type_expr * private_object_mismatch| Variance| Record_mismatch of record_mismatch| Variant_mismatch of variant_change list| Unboxed_representation of position| Immediate of Type_immediacy.Violation.tval value_descriptions :
+ loc:Location.t ->
+ Env.t ->
+ string ->
+ Types.value_description ->
+ Types.value_description ->
+ Typedtree.module_coercionval type_declarations :
+ ?equality:bool ->
+ loc:Location.t ->
+ Env.t ->
+ mark:bool ->
+ string ->
+ Types.type_declaration ->
+ Path.t ->
+ Types.type_declaration ->
+ type_mismatch optionval extension_constructors :
+ loc:Location.t ->
+ Env.t ->
+ mark:bool ->
+ Ident.t ->
+ Types.extension_constructor ->
+ Types.extension_constructor ->
+ extension_constructor_mismatch optionval report_value_mismatch :
+ string ->
+ string ->
+ Env.t ->
+ Stdlib.Format.formatter ->
+ value_mismatch ->
+ unitval report_type_mismatch :
+ string ->
+ string ->
+ string ->
+ Env.t ->
+ Stdlib.Format.formatter ->
+ type_mismatch ->
+ unitval report_extension_constructor_mismatch :
+ string ->
+ string ->
+ string ->
+ Env.t ->
+ Stdlib.Format.formatter ->
+ extension_constructor_mismatch ->
+ unitIncludemod.Errortype 'elt core_diff = ('elt, unit) difftype core_sigitem_symptom = | Value_descriptions of (Types.value_description, Includecore.value_mismatch)
+ diff| Type_declarations of (Types.type_declaration, Includecore.type_mismatch) diff| Extension_constructors of (Types.extension_constructor,
+ Includecore.extension_constructor_mismatch)
+ diff| Class_type_declarations of (Types.class_type_declaration,
+ Ctype.class_match_failure list)
+ diff| Class_declarations of (Types.class_declaration, Ctype.class_match_failure list)
+ difftype core_module_type_symptom = | Not_an_alias| Not_an_identifier| Incompatible_aliases| Abstract_module_type| Unbound_module_path of Path.ttype module_type_symptom = | Mt_core of core_module_type_symptom| Signature of signature_symptom| Functor of functor_symptom| Invalid_module_alias of Path.t| After_alias_expansion of module_type_diffand module_type_diff = (Types.module_type, module_type_symptom) diffand ('arg, 'path) functor_param_symptom = | Incompatible_params of 'arg * Types.functor_parameter| Mismatch of module_type_diffand arg_functor_param_symptom =
+ (Types.functor_parameter, Ident.t) functor_param_symptomand functor_params_diff =
+ (Types.functor_parameter list * Types.module_type) core_diffand signature_symptom = {env : Env.t;missings : Types.signature_item list;incompatibles : (Ident.t * sigitem_symptom) list;oks : (int * Typedtree.module_coercion) list;leftovers : (Types.signature_item as 'it * 'it * int) list;signature items that could not be compared due to type divergence
*)}and sigitem_symptom = | Core of core_sigitem_symptom| Module_type_declaration of (Types.modtype_declaration,
+ module_type_declaration_symptom)
+ diff| Module_type of module_type_diffand module_type_declaration_symptom = | Illegal_permutation of Typedtree.module_coercion| Not_greater_than of module_type_diff| Not_less_than of module_type_diff| Incomparable of {less_than : module_type_diff;greater_than : module_type_diff;}type all = | In_Compilation_unit of (string, signature_symptom) diff| In_Signature of signature_symptom| In_Module_type of module_type_diff| In_Module_type_substitution of Ident.t
+ * (Types.module_type, module_type_declaration_symptom) diff| In_Type_declaration of Ident.t * core_sigitem_symptom| In_Expansion of core_module_type_symptomIncludemod.FieldMapMap indexed by both field types and names. This avoids name clashes between different sorts of fields such as values and types.
type key = field_descThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Functor_app_diff.Defstype left = Error.functor_arg_descr * Types.module_typetype right = Types.functor_parametertype eq = Typedtree.module_coerciontype diff = (Error.functor_arg_descr, unit) Error.functor_param_symptomIncludemod.Functor_app_diffmodule Defs : sig ... endval diff :
+ Env.t ->
+ f:Types.module_type ->
+ args:(Error.functor_arg_descr * Types.module_type) list ->
+ Diffing.Define(Defs).patchFunctor_inclusion_diff.Defstype left = Types.functor_parametertype right = lefttype eq = Typedtree.module_coerciontype diff = (Types.functor_parameter, unit) Error.functor_param_symptomIncludemod.Functor_inclusion_diffmodule Defs : sig ... endval diff :
+ Env.t ->
+ (Types.functor_parameter list * Types.module_type) ->
+ (Types.functor_parameter list * Types.module_type) ->
+ Diffing.Define(Defs).patchIncludemodType describing which arguments of an inclusion to consider as used for the usage warnings. Mark_both is the default.
module Error : sig ... endval kind_of_field_desc : field_desc -> stringval field_desc : field_kind -> Ident.t -> field_descmodule FieldMap : Map.S with type key = field_descMap indexed by both field types and names. This avoids name clashes between different sorts of fields such as values and types.
val item_ident_name : Types.signature_item -> Ident.t * Location.t * field_descval is_runtime_component : Types.signature_item -> boolval modtypes :
+ loc:Location.t ->
+ Env.t ->
+ mark:mark ->
+ Types.module_type ->
+ Types.module_type ->
+ Typedtree.module_coercionval modtypes_with_shape :
+ shape:Shape.t ->
+ loc:Location.t ->
+ Env.t ->
+ mark:mark ->
+ Types.module_type ->
+ Types.module_type ->
+ Typedtree.module_coercion * Shape.tval strengthened_module_decl :
+ loc:Location.t ->
+ aliasable:bool ->
+ Env.t ->
+ mark:mark ->
+ Types.module_declaration ->
+ Path.t ->
+ Types.module_declaration ->
+ Typedtree.module_coercionval check_modtype_inclusion :
+ loc:Location.t ->
+ Env.t ->
+ Types.module_type ->
+ Path.t ->
+ Types.module_type ->
+ explanation optioncheck_modtype_inclusion ~loc env mty1 path1 mty2 checks that the functor application F(M) is well typed, where mty2 is the type of the argument of F and path1/mty1 is the path/unstrenghened type of M.
val check_modtype_equiv :
+ loc:Location.t ->
+ Env.t ->
+ Ident.t ->
+ Types.module_type ->
+ Types.module_type ->
+ unitval signatures :
+ Env.t ->
+ mark:mark ->
+ Types.signature ->
+ Types.signature ->
+ Typedtree.module_coercionval compunit :
+ Env.t ->
+ mark:mark ->
+ string ->
+ Types.signature ->
+ string ->
+ Types.signature ->
+ Shape.t ->
+ Typedtree.module_coercion * Shape.tval type_declarations :
+ loc:Location.t ->
+ Env.t ->
+ mark:mark ->
+ Ident.t ->
+ Types.type_declaration ->
+ Types.type_declaration ->
+ unitval print_coercion :
+ Stdlib.Format.formatter ->
+ Typedtree.module_coercion ->
+ unittype symptom = | Missing_field of Ident.t * Location.t * string| Value_descriptions of Ident.t
+ * Types.value_description
+ * Types.value_description
+ * Includecore.value_mismatch| Type_declarations of Ident.t
+ * Types.type_declaration
+ * Types.type_declaration
+ * Includecore.type_mismatch| Extension_constructors of Ident.t
+ * Types.extension_constructor
+ * Types.extension_constructor
+ * Includecore.extension_constructor_mismatch| Module_types of Types.module_type * Types.module_type| Modtype_infos of Ident.t
+ * Types.modtype_declaration
+ * Types.modtype_declaration| Modtype_permutation of Types.module_type * Typedtree.module_coercion| Interface_mismatch of string * string| Class_type_declarations of Ident.t
+ * Types.class_type_declaration
+ * Types.class_type_declaration
+ * Ctype.class_match_failure list| Class_declarations of Ident.t
+ * Types.class_declaration
+ * Types.class_declaration
+ * Ctype.class_match_failure list| Unbound_module_path of Path.t| Invalid_module_alias of Path.ttype pos = | Module of Ident.t| Modtype of Ident.t| Arg of Types.functor_parameter| Body of Types.functor_parameterexception Error of explanationexception Apply_error of {loc : Location.t;env : Env.t;lid_app : Longident.t option;mty_f : Types.module_type;args : (Error.functor_arg_descr * Types.module_type) list;}val expand_module_alias :
+ strengthen:bool ->
+ Env.t ->
+ Path.t ->
+ Types.module_typemodule Functor_inclusion_diff : sig ... endmodule Functor_app_diff : sig ... endIncludemod_errorprinterval err_msgs : Includemod.explanation -> Stdlib.Format.formatter -> unitInconstant_identsval inconstants_on_program :
+ compilation_unit:Compilation_unit.t ->
+ backend:(module Backend_intf.S) ->
+ Flambda.program ->
+ resultinconstants_on_program finds those variables and set-of-closures identifiers that cannot be compiled to constants by Flambda_to_clambda.
val variable : Variable.t -> result -> boolvariable var res returns true if var is marked as inconstant in res.
val closure : Set_of_closures_id.t -> result -> boolclosure cl res returns true if cl is marked as inconstant in res.
Initialize_symbol_to_let_symbolval constant_field :
+ Flambda.t ->
+ Flambda.constant_defining_value_block_field optionval run : Flambda.program -> Flambda.programTransform Initialize_symbol with only constant fields to let_symbol construction.
Inline_and_simplifyval run :
+ never_inline:bool ->
+ backend:(module Backend_intf.S) ->
+ prefixname:string ->
+ round:int ->
+ ppf_dump:Stdlib.Format.formatter ->
+ Flambda.program ->
+ Flambda.programSimplification of Flambda programs combined with function inlining: for the most part a beta-reduction pass.
Readers interested in the inlining strategy should read the Inlining_decision module first.
val duplicate_function :
+ env:Inline_and_simplify_aux.Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ fun_var:Variable.t ->
+ new_fun_var:Variable.t ->
+ Flambda.function_declaration * Flambda.specialised_to Variable.Map.tInline_and_simplify_aux.Envval create :
+ never_inline:bool ->
+ backend:(module Backend_intf.S) ->
+ round:int ->
+ ppf_dump:Stdlib.Format.formatter ->
+ tCreate a new environment. If never_inline is true then the returned environment will prevent Inline_and_simplify from inlining. The backend parameter is used for passing information about the compiler backend being used. Newly-created environments have inactive Freshenings (see below) and do not initially hold any approximation information.
val backend : t -> (module Backend_intf.S)Obtain the first-class module that gives information about the compiler backend being used for compilation.
val really_import_approx : t -> Simple_value_approx.t -> Simple_value_approx.tObtain the really_import_approx function from the backend module.
val round : t -> intWhich simplification round we are currently in.
val ppf_dump : t -> Stdlib.Format.formatterWhere to print intermediate asts and similar debug information
val add : t -> Variable.t -> Simple_value_approx.t -> tAdd the approximation of a variable---that is to say, some knowledge about the value(s) the variable may take on at runtime---to the environment.
val add_outer_scope : t -> Variable.t -> Simple_value_approx.t -> tval add_mutable : t -> Mutable_variable.t -> Simple_value_approx.t -> tLike add, but for mutable variables.
val find_exn : t -> Variable.t -> Simple_value_approx.tFind the approximation of a given variable, raising a fatal error if the environment does not know about the variable. Use find_opt instead if you need to catch the failure case.
val find_mutable_exn : t -> Mutable_variable.t -> Simple_value_approx.tLike find_exn, but for mutable variables.
val find_with_scope_exn : t -> Variable.t -> scope * Simple_value_approx.tval find_opt : t -> Variable.t -> Simple_value_approx.t optionLike find_exn, but intended for use where the "not present in environment" case is to be handled by the caller.
val find_list_exn : t -> Variable.t list -> Simple_value_approx.t listLike find_exn, but for a list of variables.
val does_not_bind : t -> Variable.t list -> boolval does_not_freshen : t -> Variable.t list -> boolval add_symbol : t -> Symbol.t -> Simple_value_approx.t -> tval redefine_symbol : t -> Symbol.t -> Simple_value_approx.t -> tval find_symbol_exn : t -> Symbol.t -> Simple_value_approx.tval find_symbol_opt : t -> Symbol.t -> Simple_value_approx.t optionval find_symbol_fatal : t -> Symbol.t -> Simple_value_approx.tval find_or_load_symbol : t -> Symbol.t -> Simple_value_approx.tval add_projection : t -> projection:Projection.t -> bound_to:Variable.t -> tNote that the given bound_to holds the given projection.
val find_projection : t -> projection:Projection.t -> Variable.t optionDetermine if the environment knows about a variable that is bound to the given projection.
val mem : t -> Variable.t -> boolWhether the environment has an approximation for the given variable.
val freshening : t -> Freshening.tReturn the freshening that should be applied to variables when rewriting code (in Inline_and_simplify, etc.) using the given environment.
val set_freshening : t -> Freshening.t -> tSet the freshening that should be used as per freshening, above.
Causes every bound variable in code rewritten during inlining and simplification, using the given environment, to be freshened. This is used when descending into subexpressions substituted into existing expressions.
Erase all variable approximation information and freshening information from the given environment. However, the freshening activation state is preserved. This function is used when rewriting inside a function declaration, to avoid (due to a compiler bug) accidental use of variables from outer scopes that are not accessible.
val inside_set_of_closures_declaration : Set_of_closures_origin.t -> t -> boolDetermine whether the inliner is currently inside a function body from the given set of closures. This is used to detect whether a given function call refers to a function which exists somewhere on the current inlining stack.
val at_toplevel : t -> boolNot inside a closure declaration. Toplevel code is the one evaluated when the compilation unit is loaded
val is_inside_branch : t -> boolval branch_depth : t -> intMark that call sites contained within code rewritten using the given environment should never be replaced by inlined (or unrolled) versions of the callee(s).
Equivalent to set_never_inline but only applies to code inside a set of closures.
Unset the restriction from set_never_inline_inside_closures
Equivalent to set_never_inline but does not apply to code inside a set of closures.
Unset the restriction from set_never_inline_outside_closures
val never_inline : t -> boolReturn whether set_never_inline is currently in effect on the given environment.
val inlining_level : t -> intMark that this environment is used to rewrite code for inlining. This is used by the inlining heuristics to decide whether to continue. Unconditionally inlined does not take this into account.
val actively_unrolling : t -> Set_of_closures_origin.t -> int optionWhether we are actively unrolling a given function.
val start_actively_unrolling : t -> Set_of_closures_origin.t -> int -> tStart actively unrolling a given function n times.
val continue_actively_unrolling : t -> Set_of_closures_origin.t -> tUnroll a function currently actively being unrolled.
val unrolling_allowed : t -> Set_of_closures_origin.t -> boolWhether it is permissible to unroll a call to a recursive function in the given environment.
val inside_unrolled_function : t -> Set_of_closures_origin.t -> tWhether the given environment is currently being used to rewrite the body of an unrolled recursive function.
val inlining_allowed : t -> Closure_origin.t -> boolWhether it is permissible to inline a call to a function in the given environment.
val inside_inlined_function : t -> Closure_origin.t -> tWhether the given environment is currently being used to rewrite the body of an inlined function.
val note_entering_closure :
+ t ->
+ closure_id:Closure_id.t ->
+ dbg:Debuginfo.t ->
+ tIf collecting inlining statistics, record that the inliner is about to descend into closure_id. This information enables us to produce a stack of closures that form a kind of context around an inlining decision point.
val note_entering_call : t -> closure_id:Closure_id.t -> dbg:Debuginfo.t -> tIf collecting inlining statistics, record that the inliner is about to descend into a call to closure_id. This information enables us to produce a stack of closures that form a kind of context around an inlining decision point.
If collecting inlining statistics, record that the inliner is about to descend into an inlined function call. This requires that the inliner has already entered the call with note_entering_call.
val note_entering_specialised : t -> closure_ids:Closure_id.Set.t -> tIf collecting inlining statistics, record that the inliner is about to descend into a specialised function definition. This requires that the inliner has already entered the call with note_entering_call.
val enter_closure :
+ t ->
+ closure_id:Closure_id.t ->
+ inline_inside:bool ->
+ dbg:Debuginfo.t ->
+ f:(t -> 'a) ->
+ 'aUpdate a given environment to record that the inliner is about to descend into closure_id and pass the resulting environment to f. If inline_inside is false then the environment passed to f will be marked as never_inline (see above).
val record_decision : t -> Inlining_stats_types.Decision.t -> unitIf collecting inlining statistics, record an inlining decision for the call at the top of the closure stack stored inside the given environment.
val print : Stdlib.Format.formatter -> t -> unitPrint a human-readable version of the given environment.
val set_inline_debuginfo : t -> dbg:Debuginfo.t -> tThe environment stores the call-site being inlined to produce precise location information. This function sets the current call-site being inlined.
val add_inlined_debuginfo : t -> dbg:Debuginfo.t -> Debuginfo.tAppends the locations of inlined call-sites to the ~dbg argument
Inline_and_simplify_aux.ResultResult structures approximately follow the evaluation order of the program. They are returned by the simplification algorithm acting on an Flambda subexpression.
val create : unit -> tval approx : t -> Simple_value_approx.tThe approximation of the subexpression that has just been simplified.
val set_approx : t -> Simple_value_approx.t -> tSet the approximation of the subexpression that has just been simplified. Typically used just before returning from a case of the simplification algorithm.
val meet_approx : t -> Env.t -> Simple_value_approx.t -> tSet the approximation of the subexpression to the meet of the current return approximation and the provided one. Typically used just before returning from a branch case of the simplification algorithm.
val used_static_exceptions : t -> Static_exception.Set.tAll static exceptions for which use_staticfail has been called on the given result structure.
val use_static_exception : t -> Static_exception.t -> tMark that the given static exception has been used.
val exit_scope_catch : t -> Static_exception.t -> tMark that we are moving up out of the scope of a static-catch block that catches the given static exception identifier. This has the effect of removing the identifier from the used_staticfail set.
val benefit : t -> Inlining_cost.Benefit.tThe benefit to be gained by inlining the subexpression whose simplification yielded the given result structure.
val map_benefit :
+ t ->
+ (Inlining_cost.Benefit.t -> Inlining_cost.Benefit.t) ->
+ tApply a transformation to the inlining benefit stored within the given result structure.
val add_benefit : t -> Inlining_cost.Benefit.t -> tAdd some benefit to the inlining benefit stored within the given result structure.
Set the benefit of inlining the subexpression corresponding to the given result structure to zero.
val set_inlining_threshold : t -> Inlining_cost.Threshold.t option -> tval add_inlining_threshold : t -> Inlining_cost.Threshold.t -> tval sub_inlining_threshold : t -> Inlining_cost.Threshold.t -> tval inlining_threshold : t -> Inlining_cost.Threshold.t optionval num_direct_applications : t -> intInline_and_simplify_auxEnvironments and result structures used during inlining and simplification. (See inline_and_simplify.ml.)
module Env : sig ... endmodule Result : sig ... endval initial_inlining_threshold : round:int -> Inlining_cost.Threshold.tCommand line argument -inline
val initial_inlining_toplevel_threshold :
+ round:int ->
+ Inlining_cost.Threshold.tCommand line argument -inline-toplevel
val prepare_to_simplify_set_of_closures :
+ env:Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ function_decls:Flambda.function_declarations ->
+ freshen:bool ->
+ only_for_function_decl:Flambda.function_declaration option ->
+ (Flambda.specialised_to * Simple_value_approx.t) Variable.Map.t
+ * Flambda.specialised_to Variable.Map.t
+ * Flambda.function_declarations
+ * Simple_value_approx.t Variable.Map.t
+ * Simple_value_approx.value_set_of_closures
+ * Env.tval prepare_to_simplify_closure :
+ function_decl:Flambda.function_declaration ->
+ free_vars:(Flambda.specialised_to * Simple_value_approx.t) Variable.Map.t ->
+ specialised_args:Flambda.specialised_to Variable.Map.t ->
+ parameter_approximations:Simple_value_approx.t Variable.Map.t ->
+ set_of_closures_env:Env.t ->
+ Env.tval keep_body_check :
+ is_classic_mode:bool ->
+ recursive:Variable.Set.t Stdlib.Lazy.t ->
+ Variable.t ->
+ Flambda.function_declaration ->
+ boolInlining_cost.Benefitval zero : tval remove_code_named : Flambda.named -> t -> tval remove_projection : Projection.t -> t -> tval add_code_named : Flambda.named -> t -> tval add_projection : Projection.t -> t -> tval print : Stdlib.Format.formatter -> t -> unitInlining_cost.ThresholdThe maximum size, in some abstract measure of space cost, that an Flambda expression may be in order to be inlined.
Inlining_cost.Whether_sufficient_benefitval evaluate : t -> boolval to_string : t -> stringval print_description :
+ subfunctions:bool ->
+ Stdlib.Format.formatter ->
+ t ->
+ unitInlining_costMeasurement of the cost (including cost in space) of Flambda terms in the context of inlining.
module Threshold : sig ... endval can_inline : Flambda.t -> Threshold.t -> bonus:int -> boolval can_try_inlining :
+ Flambda.t ->
+ Threshold.t ->
+ number_of_arguments:int ->
+ size_from_approximation:int option ->
+ Threshold.tmodule Benefit : sig ... endmodule Whether_sufficient_benefit : sig ... endIf a function body exceeds this size, we can make a fast decision not to inline it (see Inlining_decision).
val lambda_smaller' : Flambda.expr -> than:int -> int optionMeasure the given expression to determine whether its size is at or below the given threshold. None is returned if it is too big; otherwise Some is returned with the measured size.
val lambda_size : Flambda.expr -> intInlining_decisionSee the Flambda manual chapter for an explanation in prose of the inlining decision procedure.
val for_call_site :
+ env:Inline_and_simplify_aux.Env.t ->
+ r:Inline_and_simplify_aux.Result.t ->
+ function_decls:Simple_value_approx.function_declarations ->
+ lhs_of_application:Variable.t ->
+ closure_id_being_applied:Closure_id.t ->
+ function_decl:Simple_value_approx.function_declaration ->
+ value_set_of_closures:Simple_value_approx.value_set_of_closures ->
+ args:Variable.t list ->
+ args_approxs:Simple_value_approx.t list ->
+ dbg:Debuginfo.t ->
+ simplify:Inlining_decision_intf.simplify ->
+ inline_requested:Lambda.inline_attribute ->
+ specialise_requested:Lambda.specialise_attribute ->
+ Flambda.t * Inline_and_simplify_aux.Result.tTry to inline a full application of a known function, guided by various heuristics.
val should_inline_inside_declaration : Flambda.function_declaration -> boolWhen a function declaration is encountered by for_call_site, the body may be subject to inlining immediately, thus changing the declaration. This function must return true for that to be able to happen.
Inlining_decision_intftype 'a by_copying_function_body =
+ env:Inline_and_simplify_aux.Env.t ->
+ r:Inline_and_simplify_aux.Result.t ->
+ clos:Flambda.function_declarations ->
+ lfunc:Flambda.t ->
+ fun_id:Closure_id.t ->
+ func:Flambda.function_declaration ->
+ args:Flambda.t list ->
+ Flambda.t * Inline_and_simplify_aux.Result.ttype 'a by_copying_function_declaration =
+ env:Inline_and_simplify_aux.Env.t ->
+ r:Inline_and_simplify_aux.Result.t ->
+ funct:Flambda.t ->
+ clos:Flambda.function_declarations ->
+ fun_id:Closure_id.t ->
+ func:Flambda.function_declaration ->
+ args_with_approxs:(Flambda.t list * Simple_value_approx.t list) ->
+ invariant_params:Variable.Set.t ->
+ specialised_args:Variable.Set.t ->
+ dbg:Debuginfo.t ->
+ (Flambda.t * Inline_and_simplify_aux.Result.t) optiontype simplify =
+ Inline_and_simplify_aux.Env.t ->
+ Inline_and_simplify_aux.Result.t ->
+ Flambda.t ->
+ Flambda.t * Inline_and_simplify_aux.Result.tInlining_stats.Closure_stackval create : unit -> tval note_entering_closure :
+ t ->
+ closure_id:Closure_id.t ->
+ dbg:Debuginfo.t ->
+ tval note_entering_call : t -> closure_id:Closure_id.t -> dbg:Debuginfo.t -> tval note_entering_specialised : t -> closure_ids:Closure_id.Set.t -> tInlining_statsmodule Closure_stack : sig ... endval record_decision :
+ Inlining_stats_types.Decision.t ->
+ closure_stack:Closure_stack.t ->
+ unitInlining_stats_types.Decisiontype t = | Prevented of Prevented.t| Specialised of Specialised.t| Inlined of Not_specialised.t * Inlined.t| Unchanged of Not_specialised.t * Not_inlined.tval summary : Stdlib.Format.formatter -> t -> unitval calculation : depth:int -> Stdlib.Format.formatter -> t -> unitInlining_stats_types.Inlinedtype t = | Classic_mode| Annotation| Decl_local_to_application| Without_subfunctions of Inlining_cost.Whether_sufficient_benefit.t| With_subfunctions of Inlining_cost.Whether_sufficient_benefit.t
+ * Inlining_cost.Whether_sufficient_benefit.tInlining_stats_types.Not_inlinedtype t = | Classic_mode| Above_threshold of int| Annotation| No_useful_approximations| Unrolling_depth_exceeded| Self_call| Without_subfunctions of Inlining_cost.Whether_sufficient_benefit.t| With_subfunctions of Inlining_cost.Whether_sufficient_benefit.t
+ * Inlining_cost.Whether_sufficient_benefit.tInlining_stats_types.Not_specialisedtype t = | Classic_mode| Above_threshold of int| Annotation| Not_recursive| Not_closed| No_invariant_parameters| No_useful_approximations| Self_call| Not_beneficial of Inlining_cost.Whether_sufficient_benefit.t
+ * Inlining_cost.Whether_sufficient_benefit.tInlining_stats_types.PreventedInlining_stats_types.Specialisedtype t = | Annotation| Without_subfunctions of Inlining_cost.Whether_sufficient_benefit.t| With_subfunctions of Inlining_cost.Whether_sufficient_benefit.t
+ * Inlining_cost.Whether_sufficient_benefit.tInlining_stats_typesmodule Inlined : sig ... endmodule Not_inlined : sig ... endmodule Specialised : sig ... endmodule Not_specialised : sig ... endmodule Prevented : sig ... endmodule Decision : sig ... endInlining_transformsSource code transformations used during inlining.
val inline_by_copying_function_body :
+ env:Inline_and_simplify_aux.Env.t ->
+ r:Inline_and_simplify_aux.Result.t ->
+ lhs_of_application:Variable.t ->
+ inline_requested:Lambda.inline_attribute ->
+ specialise_requested:Lambda.specialise_attribute ->
+ closure_id_being_applied:Closure_id.t ->
+ function_decl:Simple_value_approx.function_declaration ->
+ function_body:Simple_value_approx.function_body ->
+ fun_vars:Variable.Set.t ->
+ args:Variable.t list ->
+ dbg:Debuginfo.t ->
+ simplify:Inlining_decision_intf.simplify ->
+ Flambda.t * Inline_and_simplify_aux.Result.tInline a function by substituting its body (which may be subject to further transformation) at a call site. The function's declaration is not copied.
This transformation is used when:
E.unrolling_allowed).In both cases, the body of the function is copied, within a sequence of lets that bind the function parameters, the variables "bound by the closure" (see flambda.mli), and any function identifiers introduced by the set of closures. These stages are delimited below by comments.
As an example, suppose we are inlining the following function:
let f x = x + y ... let p = f, f in (fst p) 42
The call site (fst p) 42 will be transformed to:
let clos_id = fst p in (* must eventually yield a closure *) let y = <access to y in clos_id> in let x' = 42 in let x = x' in x + y
When unrolling a recursive function we rename the arguments to the recursive call in order to avoid clashes with existing bindings. For example, suppose we are inlining the following call to f, which lies within its own declaration:
let rec f x y = f (fst x) (y + snd x)
This will be transformed to:
let rec f x y = let clos_id = f in (* not used this time, since f has no free vars *) let x' = fst x in let y' = y + snd x in f (fst x') (y' + snd x') (* body of f with parameters freshened *)
val inline_by_copying_function_declaration :
+ env:Inline_and_simplify_aux.Env.t ->
+ r:Inline_and_simplify_aux.Result.t ->
+ function_decls:Simple_value_approx.function_declarations ->
+ lhs_of_application:Variable.t ->
+ inline_requested:Lambda.inline_attribute ->
+ closure_id_being_applied:Closure_id.t ->
+ function_decl:Simple_value_approx.function_declaration ->
+ args:Variable.t list ->
+ args_approxs:Simple_value_approx.t list ->
+ invariant_params:Variable.Set.t Variable.Map.t lazy_t ->
+ specialised_args:Flambda.specialised_to Variable.Map.t ->
+ free_vars:Flambda.specialised_to Variable.Map.t ->
+ direct_call_surrogates:Closure_id.t Closure_id.Map.t ->
+ dbg:Debuginfo.t ->
+ simplify:Inlining_decision_intf.simplify ->
+ (Flambda.t * Inline_and_simplify_aux.Result.t) optionInlining of recursive function(s) yields a copy of the functions' definitions (not just their bodies, unlike the non-recursive case) and a direct application of the new body. Note: the function really does need to be recursive (but possibly only via some mutual recursion) to end up in here; a simultaneous binding that is
+ non-recursive is not sufficient.
Instructtype debug_event = {mutable ev_pos : int;ev_module : string;ev_loc : Location.t;ev_kind : debug_event_kind;ev_defname : string;ev_info : debug_event_info;ev_typenv : Env.summary;ev_typsubst : Subst.t;ev_compenv : compilation_env;ev_stacksize : int;ev_repr : debug_event_repr;}type instruction = | Klabel of label| Kacc of int| Kenvacc of int| Kpush| Kpop of int| Kassign of int| Kpush_retaddr of label| Kapply of int| Kappterm of int * int| Kreturn of int| Krestart| Kgrab of int| Kclosure of label * int| Kclosurerec of label list * int| Koffsetclosure of int| Kgetglobal of Ident.t| Ksetglobal of Ident.t| Kconst of Lambda.structured_constant| Kmakeblock of int * int| Kmakefloatblock of int| Kgetfield of int| Ksetfield of int| Kgetfloatfield of int| Ksetfloatfield of int| Kvectlength| Kgetvectitem| Ksetvectitem| Kgetstringchar| Kgetbyteschar| Ksetbyteschar| Kbranch of label| Kbranchif of label| Kbranchifnot of label| Kstrictbranchif of label| Kstrictbranchifnot of label| Kswitch of label array * label array| Kboolnot| Kpushtrap of label| Kpoptrap| Kraise of Lambda.raise_kind| Kcheck_signals| Kccall of string * int| Knegint| Kaddint| Ksubint| Kmulint| Kdivint| Kmodint| Kandint| Korint| Kxorint| Klslint| Klsrint| Kasrint| Kintcomp of Lambda.integer_comparison| Koffsetint of int| Koffsetref of int| Kisint| Kisout| Kgetmethod| Kgetpubmet of int| Kgetdynmet| Kevent of debug_event| KstopInt_replace_polymorphic_compareInterfval build_graph : Mach.fundecl -> unitInternal_variable_namesval apply_arg : tval apply_funct : tval block_symbol : tval block_symbol_get : tval block_symbol_get_field : tval closure : tval cond : tval cond_sequor : tval const_block : tval const_bool : tval const_boxed_int : tval const_char : tval const_false : tval const_float : tval const_int : tval const_one : tval const_ptr : tval const_ptr_one : tval const_ptr_zero : tval const_sequand : tval const_string : tval const_true : tval const_zero : tval denominator : tval division_by_zero : tval dummy : tval dup_func : tval dup_set_of_closures : tval const_float_array : tval fake_effect_symbol : tval for_from : tval for_to : tval from_closure : tval full_apply : tval get_symbol_field : tval const_immstring : tval const_int32 : tval const_int64 : tval ignore : tval is_zero : tval lifted_let_rec_block : tval meth : tval module_as_block : tval const_nativeint : tval new_value : tval numerator : tval obj : tval offsetted : tval partial_fun : tval pgetglobal : tval pointer : tval predef_exn : tval project_closure : tval raise : tval raise_arg : tval read_mutable : tval remove_unused_arguments : tval result : tval send_arg : tval sequence : tval set_of_closures : tval staticraise_arg : tval simplify_fv : tval string_switch : tval switch : tval symbol : tval symbol_field : tval symbol_field_block : tval the_dead_constant : tval toplevel_substitution_named : tval unbox_free_vars_of_closures : tval unit : tval zero : tval of_primitive : Lambda.primitive -> tval of_primitive_arg : Lambda.primitive -> tval anon_fn_with_loc : Lambda.scoped_location -> tIntervalval all_intervals : unit -> t listval all_fixed_intervals : unit -> t listval is_live : t -> int -> boolval remove_expired_ranges : t -> int -> unitval build_intervals : Mach.fundecl -> unitInvariant_paramsval invariant_params_in_recursion :
+ Flambda.function_declarations ->
+ backend:(module Backend_intf.S) ->
+ Variable.Set.t Variable.Map.tval invariant_param_sources :
+ Flambda.function_declarations ->
+ backend:(module Backend_intf.S) ->
+ Variable.Pair.Set.t Variable.Map.tval unused_arguments :
+ Flambda.function_declarations ->
+ backend:(module Backend_intf.S) ->
+ Variable.Set.tLambdatype primitive = | Pbytes_to_string| Pbytes_of_string| Pignore| Pgetglobal of Ident.t| Psetglobal of Ident.t| Pmakeblock of int * Asttypes.mutable_flag * block_shape| Pfield of int| Pfield_computed| Psetfield of int * immediate_or_pointer * initialization_or_assignment| Psetfield_computed of immediate_or_pointer * initialization_or_assignment| Pfloatfield of int| Psetfloatfield of int * initialization_or_assignment| Pduprecord of Types.record_representation * int| Pccall of Primitive.description| Praise of raise_kind| Psequand| Psequor| Pnot| Pnegint| Paddint| Psubint| Pmulint| Pdivint of is_safe| Pmodint of is_safe| Pandint| Porint| Pxorint| Plslint| Plsrint| Pasrint| Pintcomp of integer_comparison| Pcompare_ints| Pcompare_floats| Pcompare_bints of boxed_integer| Poffsetint of int| Poffsetref of int| Pintoffloat| Pfloatofint| Pnegfloat| Pabsfloat| Paddfloat| Psubfloat| Pmulfloat| Pdivfloat| Pfloatcomp of float_comparison| Pstringlength| Pstringrefu| Pstringrefs| Pbyteslength| Pbytesrefu| Pbytessetu| Pbytesrefs| Pbytessets| Pmakearray of array_kind * Asttypes.mutable_flag| Pduparray of array_kind * Asttypes.mutable_flagFor Pduparray, the argument must be an immutable array. The arguments of Pduparray give the kind and mutability of the array being *produced* by the duplication.
| Parraylength of array_kind| Parrayrefu of array_kind| Parraysetu of array_kind| Parrayrefs of array_kind| Parraysets of array_kind| Pisint| Pisout| Pbintofint of boxed_integer| Pintofbint of boxed_integer| Pcvtbint of boxed_integer * boxed_integer| Pnegbint of boxed_integer| Paddbint of boxed_integer| Psubbint of boxed_integer| Pmulbint of boxed_integer| Pdivbint of {size : boxed_integer;is_safe : is_safe;}| Pmodbint of {size : boxed_integer;is_safe : is_safe;}| Pandbint of boxed_integer| Porbint of boxed_integer| Pxorbint of boxed_integer| Plslbint of boxed_integer| Plsrbint of boxed_integer| Pasrbint of boxed_integer| Pbintcomp of boxed_integer * integer_comparison| Pbigarrayref of bool * int * bigarray_kind * bigarray_layout| Pbigarrayset of bool * int * bigarray_kind * bigarray_layout| Pbigarraydim of int| Pstring_load_16 of bool| Pstring_load_32 of bool| Pstring_load_64 of bool| Pbytes_load_16 of bool| Pbytes_load_32 of bool| Pbytes_load_64 of bool| Pbytes_set_16 of bool| Pbytes_set_32 of bool| Pbytes_set_64 of bool| Pbigstring_load_16 of bool| Pbigstring_load_32 of bool| Pbigstring_load_64 of bool| Pbigstring_set_16 of bool| Pbigstring_set_32 of bool| Pbigstring_set_64 of bool| Pctconst of compile_time_constant| Pbswap16| Pbbswap of boxed_integer| Pint_as_pointer| Popaqueand block_shape = value_kind list optionval equal_value_kind : value_kind -> value_kind -> boolval equal_boxed_integer : boxed_integer -> boxed_integer -> booltype structured_constant = | Const_base of Asttypes.constant| Const_block of int * structured_constant list| Const_float_array of string list| Const_immstring of stringval equal_inline_attribute : inline_attribute -> inline_attribute -> boolval equal_specialise_attribute :
+ specialise_attribute ->
+ specialise_attribute ->
+ booltype function_attribute = {inline : inline_attribute;specialise : specialise_attribute;local : local_attribute;poll : poll_attribute;is_a_functor : bool;stub : bool;tmc_candidate : bool;}type scoped_location = Debuginfo.Scoped_location.ttype lambda = | Lvar of Ident.t| Lmutvar of Ident.t| Lconst of structured_constant| Lapply of lambda_apply| Lfunction of lfunction| Llet of let_kind * value_kind * Ident.t * lambda * lambda| Lmutlet of value_kind * Ident.t * lambda * lambda| Lletrec of (Ident.t * lambda) list * lambda| Lprim of primitive * lambda list * scoped_location| Lswitch of lambda * lambda_switch * scoped_location| Lstringswitch of lambda
+ * (string * lambda) list
+ * lambda option
+ * scoped_location| Lstaticraise of int * lambda list| Lstaticcatch of lambda * int * (Ident.t * value_kind) list * lambda| Ltrywith of lambda * Ident.t * lambda| Lifthenelse of lambda * lambda * lambda| Lsequence of lambda * lambda| Lwhile of lambda * lambda| Lfor of Ident.t * lambda * lambda * Asttypes.direction_flag * lambda| Lassign of Ident.t * lambda| Lsend of meth_kind * lambda * lambda * lambda list * scoped_location| Levent of lambda * lambda_event| Lifused of Ident.t * lambdaand lfunction = private {kind : function_kind;params : (Ident.t * value_kind) list;return : value_kind;body : lambda;attr : function_attribute;loc : scoped_location;}and lambda_apply = {ap_func : lambda;ap_args : lambda list;ap_loc : scoped_location;ap_tailcall : tailcall_attribute;ap_inlined : inline_attribute;ap_specialised : specialise_attribute;}and lambda_event = {lev_loc : scoped_location;lev_kind : lambda_event_kind;lev_repr : int ref option;lev_env : Env.t;}and lambda_event_kind = | Lev_before| Lev_after of Types.type_expr| Lev_function| Lev_pseudo| Lev_module_definition of Ident.ttype program = {module_ident : Ident.t;main_module_block_size : int;required_globals : Ident.Set.t;code : lambda;}val const_unit : structured_constantval const_int : int -> structured_constantval lambda_unit : lambdaval lfunction :
+ kind:function_kind ->
+ params:(Ident.t * value_kind) list ->
+ return:value_kind ->
+ body:lambda ->
+ attr:function_attribute ->
+ loc:scoped_location ->
+ lambdaiter_head_constructor f lam apply f to only the first level of sub expressions of lam. It does not recursively traverse the expression.
Same as iter_head_constructor, but use a different callback for sub-terms which are in tail position or not.
val transl_prim : string -> string -> lambdaTranslate a value from a persistent module. For instance:
transl_internal_value "CamlinternalLazy" "force"val free_variables : lambda -> Ident.Set.tval transl_module_path : scoped_location -> Env.t -> Path.t -> lambdaval transl_value_path : scoped_location -> Env.t -> Path.t -> lambdaval transl_extension_path : scoped_location -> Env.t -> Path.t -> lambdaval transl_class_path : scoped_location -> Env.t -> Path.t -> lambdaval subst :
+ (Ident.t -> Types.value_description -> Env.t -> Env.t) ->
+ ?freshen_bound_variables:bool ->
+ lambda Ident.Map.t ->
+ lambda ->
+ lambdasubst update_env ?freshen_bound_variables s lt applies a substitution s to the lambda-term lt.
Assumes that the image of the substitution is out of reach of the bound variables of the lambda-term (no capture).
update_env is used to refresh the environment contained in debug events.
freshen_bound_variables, which defaults to false, freshens the bound variables within lt.
val rename : Ident.t Ident.Map.t -> lambda -> lambdaA version of subst specialized for the case where we're just renaming idents.
Bottom-up rewriting, applying the function on each node from the leaves to the root.
Rewrite each immediate sub-term with the function.
val negate_integer_comparison : integer_comparison -> integer_comparisonval swap_integer_comparison : integer_comparison -> integer_comparisonval negate_float_comparison : float_comparison -> float_comparisonval swap_float_comparison : float_comparison -> float_comparisonval default_function_attribute : function_attributeval default_stub_attribute : function_attributeval function_is_curried : lfunction -> boolval find_exact_application :
+ function_kind ->
+ arity:int ->
+ lambda list ->
+ lambda list optionMaximal number of parameters for a function, or in other words, maximal length of the params list of a lfunction record. This is unlimited (max_int) for bytecode, but limited (currently to 126) for native code.
val staticfail : lambdaval is_guarded : lambda -> boolval raise_kind : raise_kind -> stringval merge_inline_attributes :
+ inline_attribute ->
+ inline_attribute ->
+ inline_attribute optionLazy_backtrackval force : ('a -> 'b) -> ('a, 'b) t -> 'bval create : 'a -> ('a, 'b) tval get_arg : ('a, 'b) t -> 'a optionval get_contents : ('a, 'b) t -> ('a, 'b) Stdlib.Either.tval create_forced : 'b -> ('a, 'b) tval create_failed : exn -> ('a, 'b) tval log : unit -> logval backtrack : log -> unitLexerThe lexical analyzer
Warning: this module is unstable and part of compiler-libs.
val token : Stdlib.Lexing.lexbuf -> Parser.tokenval skip_hash_bang : Stdlib.Lexing.lexbuf -> unittype error = | Illegal_character of char| Illegal_escape of string * string option| Reserved_sequence of string * string option| Unterminated_comment of Location.t| Unterminated_string| Unterminated_string_in_comment of Location.t * Location.t| Empty_character_literal| Keyword_as_label of string| Invalid_literal of string| Invalid_directive of string * string optionexception Error of error * Location.tval print_warnings : bool refval handle_docstrings : bool refval comments : unit -> (string * Location.t) listval token_with_comments : Stdlib.Lexing.lexbuf -> Parser.tokenval set_preprocessor :
+ (unit -> unit) ->
+ ((Stdlib.Lexing.lexbuf -> Parser.token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parser.token) ->
+ unitLift_codetype lifter = Flambda.program -> Flambda.programval lift_lets : lifterLift let bindings to attempt to increase the length of scopes, as an aid to further optimizations. For example: let c = let b = <expr> in b, b in fst c would be transformed to: let b = <expr> in let c = b, b in fst c which is then clearly just: <expr>
val lifting_helper :
+ Flambda.t list ->
+ evaluation_order:[ `Left_to_right | `Right_to_left ] ->
+ create_body:(Variable.t list -> Flambda.t) ->
+ name:Internal_variable_names.t ->
+ Flambda.tLift_constantsThe aim of this pass is to assign symbols to values known to be constant (in other words, whose values we know at compile time), with appropriate sharing of constants, and replace the occurrences of the constants with their corresponding symbols.
This pass uses the results of two other passes, Inconstant_idents and Alias_analysis. The relationship between these two deserves some attention.
Inconstant_idents is a "backwards" analysis that propagates implications about inconstantness of variables and set of closures IDs.
Alias_analysis is a "forwards" analysis that is analogous to the propagation of Simple_value_approx.t values during Inline_and_simplify. It gives us information about relationships between values but not actually about their constantness.
Combining these two into a single pass has been attempted previously, but was not thought to be successful; this experiment could be repeated in the future. (If "constant" is considered as "top" and "inconstant" is considered as "bottom", then Alias_analysis corresponds to a least fixed point and Inconstant_idents corresponds to a greatest fixed point.)
At a high level, this pass operates as follows. Symbols are assigned to variables known to be constant and their defining expressions examined. Based on the results of Alias_analysis, we simplify the destructive elements within the defining expressions (specifically, projection of fields from blocks), to eventually yield Flambda.constant_defining_values that are entirely constructive. These will be bound to symbols in the resulting program.
Another approach to this pass could be to only use the results of Inconstant_idents and then repeatedly lift constants and run Inline_and_simplify until a fixpoint. It was thought more robust to instead use Alias_analysis, where the fixpointing involves a less complicated function.
We still run Inline_and_simplify once after this pass since the lifting of constants may enable more functions to become closed; the simplification pass provides an easy way of cleaning up (e.g. making sure free_vars maps in sets of closures are correct).
val lift_constants :
+ Flambda.program ->
+ backend:(module Backend_intf.S) ->
+ Flambda.programLift_let_to_initialize_symbolval lift :
+ backend:(module Backend_intf.S) ->
+ Flambda.program ->
+ Flambda.programLift toplevel Let-expressions to Flambda program constructions such that the results of evaluation of such expressions may be accessed directly, through symbols, rather than through closures. The Let-expressions typically come from the compilation of modules (using the bytecode strategy) in Translmod.
This means of compilation supersedes the old "transl_store_" methodology for native code.
An Initialize_symbol construction generated by this pass may be subsequently rewritten to Let_symbol if it is discovered that the initializer is in fact constant. (See Initialize_symbol_to_let_symbol.)
The program constructions generated by this pass will be joined by others that arise from the lifting of constants (see Lift_constants).
Lineartype label = Cmm.labeltype instruction = {mutable desc : instruction_desc;mutable next : instruction;arg : Reg.t array;res : Reg.t array;dbg : Debuginfo.t;live : Reg.Set.t;}and instruction_desc = | Lprologue| Lend| Lop of Mach.operation| Lreloadretaddr| Lreturn| Llabel of label| Lbranch of label| Lcondbranch of Mach.test * label| Lcondbranch3 of label option * label option * label option| Lswitch of label array| Lentertrap| Ladjust_trap_depth of {}| Lpushtrap of {lbl_handler : label;}| Lpoptrap| Lraise of Lambda.raise_kindval has_fallthrough : instruction_desc -> boolval end_instr : instructionval instr_cons :
+ instruction_desc ->
+ Reg.t array ->
+ Reg.t array ->
+ instruction ->
+ instructiontype fundecl = {fun_name : string;fun_body : instruction;fun_fast : bool;fun_dbg : Debuginfo.t;fun_tailrec_entry_point_label : label;fun_contains_calls : bool;fun_num_stack_slots : int array;fun_frame_required : bool;fun_prologue_required : bool;}Linear_formattype linear_unit_info = {mutable unit_name : string;mutable items : linear_item_info list;mutable for_pack : string option;}val save : string -> linear_unit_info -> unitval restore : string -> linear_unit_info * Stdlib.Digest.tLinearizeval fundecl : Mach.fundecl -> Linear.fundeclLinkage_name.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitLinkage_name.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringLinkage_name.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitLinkage_name.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tLinkage_nameinclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create : string -> tval to_string : t -> stringLinscanLivenessval fundecl : Mach.fundecl -> unitLoad_path.Dirval create : string -> tval path : t -> stringval files : t -> string listAll the files in that directory. This doesn't include files in sub-directories of this directory.
Load_pathManagement of include directories.
This module offers a high level interface to locating files in the load path, which is constructed from -I command line flags and a few other parameters.
It makes the assumption that the contents of include directories doesn't change during the execution of the compiler.
Locate a file in the load path. Raise Not_found if the file cannot be found. This function is optimized for the case where the filename is a basename, i.e. doesn't contain a directory separator.
Same as find, but search also for uncapitalized name, i.e. if name is Foo.ml, allow /path/Foo.ml and /path/foo.ml to match.
module Dir : sig ... endval add : Dir.t -> unitOld name for append_dir
val append_dir : Dir.t -> unitappend_dir d adds d to the end of the load path (i.e. at lowest priority.
val prepend_dir : Dir.t -> unitprepend_dir d adds d to the start of the load path (i.e. at highest priority.
val get : unit -> Dir.t listSame as get_paths (), except that it returns a Dir.t list.
Local_storeThis module provides some facilities for creating references (and hash tables) which can easily be snapshoted and restored to an arbitrary version.
It is used throughout the frontend (read: typechecker), to register all (well, hopefully) the global state. Thus making it easy for tools like Merlin to go back and forth typechecking different files.
val s_ref : 'a -> 'a refSimilar to ref, except the allocated reference is registered into the store.
val s_table : ('a -> 'b) -> 'a -> 'b refUsed to register hash tables. Those also need to be placed into refs to be easily swapped out, but one can't just "snapshot" the initial value to create fresh instances, so instead an initializer is required.
Use it like this:
let my_table = s_table Hashtbl.create 42Note: all the following functions are currently unused inside the compiler codebase. Merlin is their only user at the moment.
val fresh : unit -> storeReturns a fresh instance of the store.
The first time this function is called, it snapshots the value of all the registered references, later calls to fresh will return instances initialized to those values.
val with_store : store -> (unit -> 'a) -> 'awith_store s f resets all the registered references to the value they have in s for the run of f. If f updates any of the registered refs, s is updated to remember those changes.
Resets all the references to the initial snapshot (i.e. to the same values that new instances start with).
Returns true when a store is active (i.e. when called from the callback passed to with_store), false otherwise.
LocationSource code locations (ranges of positions), used in parsetree.
Warning: this module is unstable and part of compiler-libs.
type t = Warnings.loc = {loc_start : Stdlib.Lexing.position;loc_end : Stdlib.Lexing.position;loc_ghost : bool;}Note on the use of Lexing.position in this module. If pos_fname = "", then use !input_name instead. If pos_lnum = -1, then pos_bol = 0. Use pos_cnum and re-parse the file to get the line and character numbers. Else all fields are correct.
val none : tAn arbitrary value of type t; describes an empty ghost range.
val is_none : t -> boolTrue for Location.none, false any other location
val in_file : string -> tReturn an empty ghost range located in a given file.
val init : Stdlib.Lexing.lexbuf -> string -> unitSet the file name and line number of the lexbuf to be the start of the named file.
val curr : Stdlib.Lexing.lexbuf -> tGet the location of the current token from the lexbuf.
val symbol_rloc : unit -> tval symbol_gloc : unit -> tval rhs_loc : int -> trhs_loc n returns the location of the symbol at position n, starting at 1, in the current parser rule.
val rhs_interval : int -> int -> tval get_pos_info : Stdlib.Lexing.position -> string * int * intfile, line, char
val mknoloc : 'a -> 'a locval input_name : string refval input_lexbuf : Stdlib.Lexing.lexbuf option refval input_phrase_buffer : Stdlib.Buffer.t option refrewrite absolute path to honor the BUILD_PATH_PREFIX_MAP variable (https://reproducible-builds.org/specs/build-path-prefix-map/) if it is set.
In -absname mode, return the absolute path for this filename. Otherwise, returns the filename unchanged.
val print_filename : Stdlib.Format.formatter -> string -> unitval print_loc : Stdlib.Format.formatter -> t -> unitval print_locs : Stdlib.Format.formatter -> t list -> unitval highlight_terminfo :
+ Stdlib.Lexing.lexbuf ->
+ Stdlib.Format.formatter ->
+ t list ->
+ unittype msg = (Stdlib.Format.formatter -> unit) locval msg : ?loc:t -> ('a, Stdlib.Format.formatter, unit, msg) format4 -> 'atype report_printer = {pp : report_printer -> Stdlib.Format.formatter -> report -> unit;pp_report_kind : report_printer ->
+ report ->
+ Stdlib.Format.formatter ->
+ report_kind ->
+ unit;pp_main_loc : report_printer -> report -> Stdlib.Format.formatter -> t -> unit;pp_main_txt : report_printer ->
+ report ->
+ Stdlib.Format.formatter ->
+ (Stdlib.Format.formatter -> unit) ->
+ unit;pp_submsgs : report_printer ->
+ report ->
+ Stdlib.Format.formatter ->
+ msg list ->
+ unit;pp_submsg : report_printer -> report -> Stdlib.Format.formatter -> msg -> unit;pp_submsg_loc : report_printer ->
+ report ->
+ Stdlib.Format.formatter ->
+ t ->
+ unit;pp_submsg_txt : report_printer ->
+ report ->
+ Stdlib.Format.formatter ->
+ (Stdlib.Format.formatter -> unit) ->
+ unit;}A printer for reports, defined using open-recursion. The goal is to make it easy to define new printers by re-using code from existing ones.
val batch_mode_printer : report_printerval terminfo_toplevel_printer : Stdlib.Lexing.lexbuf -> report_printerval best_toplevel_printer : unit -> report_printerDetects the terminal capabilities and selects an adequate printer
reportval print_report : Stdlib.Format.formatter -> report -> unitDisplay an error or warning report.
val report_printer : (unit -> report_printer) refHook for redefining the printer of reports.
The hook is a unit -> report_printer and not simply a report_printer: this is useful so that it can detect the type of the output (a file, a terminal, ...) and select a printer accordingly.
val default_report_printer : unit -> report_printerOriginal report printer for use in hooks.
Warnings.t into a reportval report_warning : t -> Warnings.t -> report optionreport_warning loc w produces a report for the given warning w, or None if the warning is not to be printed.
val warning_reporter : (t -> Warnings.t -> report option) refHook for intercepting warnings.
val default_warning_reporter : t -> Warnings.t -> report optionOriginal warning reporter for use in hooks.
val formatter_for_warnings : Stdlib.Format.formatter refval print_warning : t -> Stdlib.Format.formatter -> Warnings.t -> unitPrints a warning. This is simply the composition of report_warning and print_report.
val prerr_warning : t -> Warnings.t -> unitSame as print_warning, but uses !formatter_for_warnings as output formatter.
Alert.t into a reportval report_alert : t -> Warnings.alert -> report optionreport_alert loc w produces a report for the given alert w, or None if the alert is not to be printed.
val alert_reporter : (t -> Warnings.alert -> report option) refHook for intercepting alerts.
val default_alert_reporter : t -> Warnings.alert -> report optionOriginal alert reporter for use in hooks.
val print_alert : t -> Stdlib.Format.formatter -> Warnings.alert -> unitPrints an alert. This is simply the composition of report_alert and print_report.
val prerr_alert : t -> Warnings.alert -> unitSame as print_alert, but uses !formatter_for_warnings as output formatter.
type error = reportAn error is a report which report_kind must be Report_error.
val errorf :
+ ?loc:t ->
+ ?sub:msg list ->
+ ('a, Stdlib.Format.formatter, unit, error) format4 ->
+ 'aval error_of_printer :
+ ?loc:t ->
+ ?sub:msg list ->
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a ->
+ errorval error_of_printer_file :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a ->
+ errorval register_error_of_exn : (exn -> error option) -> unitEach compiler module which defines a custom type of exception which can surface as a user-visible error should register a "printer" for this exception using register_error_of_exn. The result of the printer is an error value containing a location, a message, and optionally sub-messages (each of them being located as well).
val error_of_exn : exn -> [ `Ok of error | `Already_displayed ] optionexception Error of errorRaising Error e signals an error e; the exception will be caught and the error will be printed.
Raising Already_displayed_error signals an error which has already been printed. The exception will be caught, but nothing will be printed
val raise_errorf :
+ ?loc:t ->
+ ?sub:msg list ->
+ ('a, Stdlib.Format.formatter, unit, 'b) format4 ->
+ 'aval report_exception : Stdlib.Format.formatter -> exn -> unitReraise the exception if it is unknown.
LongidentLong identifiers, used in parsetree.
Warning: this module is unstable and part of compiler-libs.
To print a longident, see Pprintast.longident, using Format.asprintf to convert to a string.
val flatten : t -> string listval unflatten : string list -> t optionFor a non-empty list l, unflatten l is Some lid where lid is the long identifier created by concatenating the elements of l with Ldot. unflatten [] is None.
val last : t -> stringval parse : string -> tThis function is broken on identifiers that are not just "Word.Word.word"; for example, it returns incorrect results on infix operators and extended module paths.
If you want to generate long identifiers that are a list of dot-separated identifiers, the function unflatten is safer and faster. unflatten is available since OCaml 4.06.0.
If you want to parse any identifier correctly, use the long-identifiers functions from the Parse module, in particular Parse.longident. They are available since OCaml 4.11, and also provide proper input-location support.
Machtype integer_operation = | Iadd| Isub| Imul| Imulh| Idiv| Imod| Iand| Ior| Ixor| Ilsl| Ilsr| Iasr| Icomp of integer_comparison| Icheckboundtype float_comparison = Cmm.float_comparisontype test = | Itruetest| Ifalsetest| Iinttest of integer_comparison| Iinttest_imm of integer_comparison * int| Ifloattest of float_comparison| Ioddtest| Ieventesttype operation = | Imove| Ispill| Ireload| Iconst_int of nativeint| Iconst_float of int64| Iconst_symbol of string| Icall_ind| Icall_imm of {}| Itailcall_ind| Itailcall_imm of {}| Iextcall of {func : string;ty_res : Cmm.machtype;ty_args : Cmm.exttype list;alloc : bool;}| Istackoffset of int| Iload of Cmm.memory_chunk * Arch.addressing_mode * Asttypes.mutable_flag| Istore of Cmm.memory_chunk * Arch.addressing_mode * bool| Ialloc of {bytes : int;dbginfo : Debuginfo.alloc_dbginfo;}| Iintop of integer_operation| Iintop_imm of integer_operation * int| Inegf| Iabsf| Iaddf| Isubf| Imulf| Idivf| Ifloatofint| Iintoffloat| Iopaque| Ispecific of Arch.specific_operation| Ipoll of {return_label : Cmm.label option;}type instruction = {desc : instruction_desc;next : instruction;arg : Reg.t array;res : Reg.t array;dbg : Debuginfo.t;mutable live : Reg.Set.t;}and instruction_desc = | Iend| Iop of operation| Ireturn| Iifthenelse of test * instruction * instruction| Iswitch of int array * instruction array| Icatch of Cmm.rec_flag * (int * instruction) list * instruction| Iexit of int| Itrywith of instruction * instruction| Iraise of Lambda.raise_kindtype fundecl = {fun_name : string;fun_args : Reg.t array;fun_body : instruction;fun_codegen_options : Cmm.codegen_option list;fun_dbg : Debuginfo.t;fun_poll : Lambda.poll_attribute;fun_num_stack_slots : int array;fun_contains_calls : bool;}val dummy_instr : instructionval end_instr : unit -> instructionval instr_cons :
+ instruction_desc ->
+ Reg.t array ->
+ Reg.t array ->
+ instruction ->
+ instructionval instr_cons_debug :
+ instruction_desc ->
+ Reg.t array ->
+ Reg.t array ->
+ Debuginfo.t ->
+ instruction ->
+ instructionval instr_iter : (instruction -> unit) -> instruction -> unitval operation_is_pure : operation -> boolReturns true if the given operation only produces a result in its destination registers, but has no side effects whatsoever: it doesn't raise exceptions, it doesn't modify already-allocated blocks, it doesn't adjust the stack frame, etc.
val operation_can_raise : operation -> boolReturns true if the given operation can raise an exception.
MainDefault.Maininclude Core_optionsinclude Common_optionsinclude Compiler_optionsDefault.Odoc_argsinclude Common_optionsDefault.OptmainDefault.Opttopmaininclude Toplevel_optionsinclude Core_optionsinclude Common_optionsinclude Optcommon_optionsDefault.Topmaininclude Toplevel_optionsinclude Core_optionsinclude Common_optionsMain_args.Defaultmodule Topmain : Bytetop_optionsmodule Opttopmain : Opttop_optionsmodule Main : Bytecomp_optionsmodule Optmain : Optcomp_optionsmodule Odoc_args : Ocamldoc_optionsMake_bytecomp_options._include Core_optionsinclude Common_optionsinclude Compiler_optionsMain_args.Make_bytecomp_optionsMake_bytetop_options._include Toplevel_optionsinclude Core_optionsinclude Common_optionsMain_args.Make_bytetop_optionsMake_ocamldoc_options._include Common_optionsMain_args.Make_ocamldoc_optionsMake_optcomp_options._Main_args.Make_optcomp_optionsMake_opttop_options._include Toplevel_optionsinclude Core_optionsinclude Common_optionsinclude Optcommon_optionsMain_args.Make_opttop_optionsMain_argsmodule type Common_options = sig ... endmodule type Core_options = sig ... endmodule type Compiler_options = sig ... endmodule type Toplevel_options = sig ... endmodule type Bytecomp_options = sig ... endmodule type Bytetop_options = sig ... endmodule type Optcommon_options = sig ... endmodule type Optcomp_options = sig ... endmodule type Opttop_options = sig ... endmodule type Ocamldoc_options = sig ... endmodule type Arg_list = sig ... endmodule Make_bytecomp_options (_ : Bytecomp_options) : Arg_listmodule Make_bytetop_options (_ : Bytetop_options) : Arg_listmodule Make_optcomp_options (_ : Optcomp_options) : Arg_listmodule Make_opttop_options (_ : Opttop_options) : Arg_listmodule Make_ocamldoc_options (_ : Ocamldoc_options) : Arg_listval options_with_command_line_syntax :
+ (string * Stdlib.Arg.spec * string) list ->
+ string list ref ->
+ (string * Stdlib.Arg.spec * string) listoptions_with_command_line_syntax options r returns options2 that behaves like options, but additionally pushes command line argument on r (quoted by Filename.quote when necessary). This is meant for ocamlc,optp, which use this to forward most of their arguments to ocamlc,opt.
module Default : sig ... endMain_args.Arg_listval list : (string * Stdlib.Arg.spec * string) listMain_args.Bytecomp_optionsinclude Core_optionsinclude Common_optionsinclude Compiler_optionsMain_args.Bytetop_optionsinclude Toplevel_optionsinclude Core_optionsinclude Common_optionsMain_args.Common_optionsMain_args.Compiler_optionsMain_args.Core_optionsinclude Common_optionsMain_args.Ocamldoc_optionsinclude Common_optionsMain_args.Optcommon_optionsMain_args.Optcomp_optionsMain_args.Opttop_optionsinclude Toplevel_optionsinclude Core_optionsinclude Common_optionsinclude Optcommon_optionsMain_args.Toplevel_optionsinclude Core_optionsinclude Common_optionsMaindriverval main : string array -> Stdlib.Format.formatter -> intMakedependMatchingval for_function :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Location.t ->
+ int ref option ->
+ Lambda.lambda ->
+ (Typedtree.pattern * Lambda.lambda) list ->
+ Typedtree.partial ->
+ Lambda.lambdaval for_trywith :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Location.t ->
+ Lambda.lambda ->
+ (Typedtree.pattern * Lambda.lambda) list ->
+ Lambda.lambdaval for_let :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Location.t ->
+ Lambda.lambda ->
+ Typedtree.pattern ->
+ Lambda.lambda ->
+ Lambda.lambdaval for_multiple_match :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Location.t ->
+ Lambda.lambda list ->
+ (Typedtree.pattern * Lambda.lambda) list ->
+ Typedtree.partial ->
+ Lambda.lambdaval for_tupled_function :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Location.t ->
+ Ident.t list ->
+ (Typedtree.pattern list * Lambda.lambda) list ->
+ Typedtree.partial ->
+ Lambda.lambdaval flatten_pattern : int -> Typedtree.pattern -> Typedtree.pattern listval expand_stringswitch :
+ Lambda.scoped_location ->
+ Lambda.lambda ->
+ (string * Lambda.lambda) list ->
+ Lambda.lambda option ->
+ Lambda.lambdaval inline_lazy_force :
+ Lambda.lambda ->
+ Lambda.scoped_location ->
+ Lambda.lambdaMetaval global_data : unit -> Stdlib.Obj.t arraytype closure = unit -> Stdlib.Obj.tval reify_bytecode :
+ bytes array ->
+ Instruct.debug_event list array ->
+ string option ->
+ bytecode * closureval release_bytecode : bytecode -> unitval invoke_traced_function :
+ Stdlib.Obj.raw_data ->
+ Stdlib.Obj.t ->
+ Stdlib.Obj.t ->
+ Stdlib.Obj.tval get_section_table : unit -> (string * Stdlib.Obj.t) listMisc.Colorval ansi_of_style_l : style list -> stringval default_styles : stylesval get_styles : unit -> stylesval set_styles : styles -> unitval default_setting : settingval setup : setting option -> unitval set_color_tag_handling : Stdlib.Format.formatter -> unitMisc.Error_styleval default_setting : settingMisc.Int_literal_converterMisc.LongStringval create : int -> tval length : t -> intval get : t -> int -> charval set : t -> int -> char -> unitval blit_string : string -> int -> t -> int -> int -> unitval output : out_channel -> t -> int -> int -> unitval input_bytes_into : t -> in_channel -> int -> unitval input_bytes : in_channel -> int -> tMisc.Magic_numbera typical magic number is "Caml1999I011"; it is formed of an alphanumeric prefix, here Caml1990I, followed by a version, here 011. The prefix identifies the kind of the versioned data: here the I indicates that it is the magic number for .cmi files.
All magic numbers have the same byte length, magic_length, and this is important for users as it gives them the number of bytes to read to obtain the byte sequence that should be a magic number. Typical user code will look like:
let ic = open_in_bin path in
+let magic =
+ try really_input_string ic Magic_number.magic_length
+ with End_of_file -> ... in
+match Magic_number.parse magic with
+| Error parse_error -> ...
+| Ok info -> ...A given compiler version expects one specific version for each kind of object file, and will fail if given an unsupported version. Because versions grow monotonically, you can compare the parsed version with the expected "current version" for a kind, to tell whether the wrong-magic object file comes from the past or from the future.
An example of code block that expects the "currently supported version" of a given kind of magic numbers, here Cmxa, is as follows:
let ic = open_in_bin path in
+begin
+ try Magic_number.(expect_current Cmxa (get_info ic)) with
+ | Parse_error error -> ...
+ | Unexpected error -> ...
+end;
+...Parse errors distinguish inputs that are Not_a_magic_number str, which are likely to come from the file being completely different, and Truncated str, raised by headers that are the (possibly empty) prefix of a valid magic number.
Unexpected errors correspond to valid magic numbers that are not the one expected, either because it corresponds to a different kind, or to a newer or older version.
The helper functions explain_parse_error and explain_unexpected_error will generate a textual explanation of each error, for use in error messages.
native object files have a format and magic number that depend on certain native-compiler configuration parameters. This configuration space is expressed by the native_obj_config type.
val native_obj_config : native_obj_configthe native object file configuration of the active/configured compiler.
type kind = | Exec| Cmi| Cmo| Cma| Cmx of native_obj_config| Cmxa of native_obj_config| Cmxs| Cmt| Ast_impl| Ast_intftype info = {kind : kind;version : version;Note: some versions of the compiler use the same version suffix for all kinds, but others use different versions counters for different kinds. We may only assume that versions are growing monotonically (not necessarily always by one) between compiler versions.
}the type of raw magic numbers, such as "Caml1999A027" for the .cma files of OCaml 4.10
val explain_parse_error : kind option -> parse_error -> stringProduces an explanation for a parse error. If no kind is provided, we use an unspecific formulation suggesting that any compiler-produced object file would have been satisfying.
val parse : raw -> (info, parse_error) resultParses a raw magic number
val read_info : in_channel -> (info, parse_error) resultRead a raw magic number from an input channel.
If the data read str is not a valid magic number, it can be recovered from the Truncated str | Not_a_magic_number str payload of the Error parse_error case.
If parsing succeeds with an Ok info result, we know that exactly magic_length bytes have been consumed from the input_channel.
If you also wish to enforce that the magic number is at the current version, see read_current_info below.
val check_current : kind -> info -> (unit, unexpected_error) resultcheck_current kind info checks that the provided magic info is the current version of kind's magic header.
val explain_unexpected_error : unexpected_error -> stringProvides an explanation of the unexpected_error.
val read_current_info :
+ expected_kind:kind option ->
+ in_channel ->
+ (info, error) resultRead a magic number as read_info, and check that it is the current version as its kind. If the expected_kind argument is None, any kind is accepted.
val string_of_kind : kind -> stringa user-printable string for a kind, eg. "exec" or "cmo", to use in error messages.
val human_name_of_kind : kind -> stringa user-meaningful name for a kind, eg. "executable file" or "bytecode object file", to use in error messages.
Mainly for internal usage and testing.
the current raw representation of a kind.
In some cases the raw representation of a kind has changed over compiler versions, so other files of the same kind may have different raw kinds. Note that all currently known cases are parsed correctly by parse_kind.
A valid raw representation of the magic number.
Due to past and future changes in the string representation of magic numbers, we cannot guarantee that the raw strings returned for past and future versions actually match the expectations of those compilers. The representation is accurate for current versions, and it is correctly parsed back into the desired version by the parsing functions above.
Stdlib.ArraySame as Array.exists2 from the standard library.
Same as Array.for_all from the standard library, but the function is applied with the index of the element as first argument, and the element itself as second argument.
Stdlib.ListThe lexicographic order supported by the provided order. There is no constraint on the relative lengths of the lists.
Returns true if and only if the given lists have the same length and content with respect to the given equality function.
If all elements of the given list are Some _ then Some xs is returned with the xs being the contents of those Somes, with order preserved. Otherwise return None.
let r1, r2 = map2_prefix f l1 l2 If l1 is of length n and l2 = h2 @ t2 with h2 of length n, r1 is List.map2 f l1 h1 and r2 is t2.
split_at n l returns the pair before, after where before is the n first elements of l and after the remaining ones. If l has less than n elements, raises Invalid_argument.
Returns true if and only if the given list, with respect to the given equality function on list members, is a prefix of the list of_.
val find_and_chop_longest_common_prefix :
+ equal:('a -> 'a -> bool) ->
+ first:'a list ->
+ second:'a list ->
+ 'a longest_common_prefix_resultReturns the longest list that, with respect to the provided equality function, is a prefix of both of the given lists. The input lists, each with such longest common prefix removed, are also returned.
Stdlib.Optionval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitString.Mapval empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
String.Setval empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
String.Tblval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsStdlib.Stringinclude module type of Stdlib.Stringmake n c is a string of length n with each index holding the character c.
init n f is a string of length n with index i holding the character f i (called in increasing index order).
Return a new string that contains the same bytes as the given byte sequence.
Return a new byte sequence that contains the same bytes as the given string.
get s i is the character at index i in s. This is the same as writing s.[i].
Note. The Stdlib.(^) binary operator concatenates two strings.
concat sep ss concatenates the list of strings ss, inserting the separator string sep between each.
compare s0 s1 sorts s0 and s1 in lexicographical order. compare behaves like Stdlib.compare on strings but may be more efficient.
starts_with ~prefix s is true if and only if s starts with prefix.
ends_with ~suffix s is true if and only if s ends with suffix.
contains_from s start c is true if and only if c appears in s after position start.
rcontains_from s stop c is true if and only if c appears in s before position stop+1.
contains s c is String.contains_from s 0 c.
sub s pos len is a string of length len, containing the substring of s that starts at position pos and has length len.
split_on_char sep s is the list of all (possibly empty) substrings of s that are delimited by the character sep.
The function's result is specified by the following invariants:
sep as a separator returns a string equal to the input (concat (make 1 sep)
+ (split_on_char sep s) = s).sep character.map f s is the string resulting from applying f to all the characters of s in increasing order.
mapi f s is like map but the index of the character is also passed to f.
fold_left f x s computes f (... (f (f x s.[0]) s.[1]) ...) s.[n-1], where n is the length of the string s.
fold_right f s x computes f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)), where n is the length of the string s.
exists p s checks if at least one character of s satisfies the predicate p.
trim s is s without leading and trailing whitespace. Whitespace characters are: ' ', '\x0C' (form feed), '\n', '\r', and '\t'.
escaped s is s with special characters represented by escape sequences, following the lexical conventions of OCaml.
All characters outside the US-ASCII printable range [0x20;0x7E] are escaped, as well as backslash (0x2F) and double-quote (0x22).
The function Scanf.unescaped is a left inverse of escaped, i.e. Scanf.unescaped (escaped s) = s for any string s (unless escaped s fails).
uppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.
lowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.
capitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.
uncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.
iter f s applies function f in turn to all the characters of s. It is equivalent to f s.[0]; f s.[1]; ...; f s.[length s - 1]; ().
iteri is like iter, but the function is also given the corresponding character index.
index_from s i c is the index of the first occurrence of c in s after position i.
index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).
rindex_from s i c is the index of the last occurrence of c in s before position i+1.
rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).
index s c is String.index_from s 0 c.
index_opt s c is String.index_from_opt s 0 c.
rindex s c is String.rindex_from s (length s - 1) c.
rindex_opt s c is String.rindex_from_opt s (length s - 1) c.
val to_seq : t -> char Stdlib.Seq.tto_seq s is a sequence made of the string's characters in increasing order. In "unsafe-string" mode, modifications of the string during iteration will be reflected in the sequence.
val to_seqi : t -> (int * char) Stdlib.Seq.tto_seqi s is like to_seq but also tuples the corresponding index.
val of_seq : char Stdlib.Seq.t -> tof_seq s is a string made of the sequence's characters.
val get_utf_8_uchar : t -> int -> Stdlib.Uchar.utf_decodeget_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val is_valid_utf_8 : t -> boolis_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
val get_utf_16be_uchar : t -> int -> Stdlib.Uchar.utf_decodeget_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val is_valid_utf_16be : t -> boolis_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
val get_utf_16le_uchar : t -> int -> Stdlib.Uchar.utf_decodeget_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val is_valid_utf_16le : t -> boolis_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
create n returns a fresh byte sequence of length n. The sequence is uninitialized and contains arbitrary bytes.
set s n c modifies byte sequence s in place, replacing the byte at index n with c. You can also write s.[n] <- c instead of set s n c.
blit src src_pos dst dst_pos len copies len bytes from the string src, starting at index src_pos, to byte sequence dst, starting at character number dst_pos.
fill s pos len c modifies byte sequence s in place, replacing len bytes by c, starting at pos.
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..
Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
The functions in this section binary decode integers from strings.
All following functions raise Invalid_argument if the characters needed at index i to decode the integer are not available.
Little-endian (resp. big-endian) encoding means that least (resp. most) significant bytes are stored first. Big-endian is also known as network byte order. Native-endian encoding is either little-endian or big-endian depending on Sys.big_endian.
32-bit and 64-bit integers are represented by the int32 and int64 types, which can be interpreted either as signed or unsigned numbers.
8-bit and 16-bit integers are represented by the int type, which has more bits than the binary encoding. These extra bits are sign-extended (or zero-extended) for functions which decode 8-bit or 16-bit integers and represented them with int values.
get_uint8 b i is b's unsigned 8-bit integer starting at character index i.
get_int8 b i is b's signed 8-bit integer starting at character index i.
get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.
get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.
get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.
get_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.
get_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.
get_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.
get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.
get_int32_be b i is b's big-endian 32-bit integer starting at character index i.
get_int32_le b i is b's little-endian 32-bit integer starting at character index i.
get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.
get_int64_be b i is b's big-endian 64-bit integer starting at character index i.
val print : Stdlib.Format.formatter -> t -> unitval for_all : (char -> bool) -> t -> boolMisc.Stdlibmodule List : sig ... endmodule Option : sig ... endmodule Array : sig ... endmodule String : sig ... endMiscMiscellaneous useful types and functions
Warning: this module is unstable and part of compiler-libs.
val fatal_errorf : ('a, Stdlib.Format.formatter, unit, 'b) format4 -> 'aval try_finally :
+ ?always:(unit -> unit) ->
+ ?exceptionally:(unit -> unit) ->
+ (unit -> 'a) ->
+ 'atry_finally work ~always ~exceptionally is designed to run code in work that may fail with an exception, and has two kind of cleanup routines: always, that must be run after any execution of the function (typically, freeing system resources), and exceptionally, that should be run only if work or always failed with an exception (typically, undoing user-visible state changes that would only make sense if the function completes correctly). For example:
let objfile = outputprefix ^ ".cmo" in
+let oc = open_out_bin objfile in
+Misc.try_finally
+ (fun () ->
+ bytecode
+ ++ Timings.(accumulate_time (Generate sourcefile))
+ (Emitcode.to_file oc modulename objfile);
+ Warnings.check_fatal ())
+ ~always:(fun () -> close_out oc)
+ ~exceptionally:(fun _exn -> remove_file objfile);If exceptionally fail with an exception, it is propagated as usual.
If always or exceptionally use exceptions internally for control-flow but do not raise, then try_finally is careful to preserve any exception backtrace coming from work or always for easier debugging.
reraise_preserving_backtrace e f is (f (); raise e) except that the current backtrace is preserved, even if f uses exceptions internally.
val protect_refs : ref_and_value list -> (unit -> 'a) -> 'aprotect_refs l f temporarily sets r to v for each R (r, v) in l while executing f. The previous contents of the references is restored even if f raises an exception, without altering the exception backtrace.
module Stdlib : sig ... endval create_hashtable : int -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.tval copy_file : in_channel -> out_channel -> unitval copy_file_chunk : in_channel -> out_channel -> int -> unitval string_of_file : in_channel -> stringval output_to_file_via_temporary :
+ ?mode:open_flag list ->
+ string ->
+ (string -> out_channel -> 'a) ->
+ 'aval protect_writing_to_file : filename:string -> f:(out_channel -> 'a) -> 'aOpen the given filename for writing (in binary mode), pass the out_channel to the given function, then close the channel. If the function raises an exception then filename will be removed.
module Int_literal_converter : sig ... endval get_ref : 'a list ref -> 'a listval set_or_ignore : ('a -> 'b option) -> 'b option ref -> 'a -> unitmodule LongString : sig ... endedit_distance a b cutoff computes the edit distance between strings a and b. To help efficiency, it uses a cutoff: if the distance d is smaller than cutoff, it returns Some d, else None.
The distance algorithm currently used is Damerau-Levenshtein: it computes the number of insertion, deletion, substitution of letters, or swapping of adjacent letters to go from one word to the other. The particular algorithm may change in the future.
spellcheck env name takes a list of names env that exist in the current environment and an erroneous name, and returns a list of suggestions taken from env, that are close enough to name that it may be a typo for one of them.
val did_you_mean : Stdlib.Format.formatter -> (unit -> string list) -> unitdid_you_mean ppf get_choices hints that the user may have meant one of the option returned by calling get_choices. It does nothing if the returned list is empty.
The unit -> ... thunking is meant to delay any potentially-slow computation (typically computing edit-distance with many things from the current environment) to when the hint message is to be printed. You should print an understandable error message before calling did_you_mean, so that users get a clear notification of the failure even if producing the hint is slow.
String.cut_at s c returns a pair containing the sub-string before the first occurrence of c in s, and the sub-string after the first occurrence of c in s. let (before, after) = String.cut_at s c in
+ before ^ String.make 1 c ^ after is the identity if s contains c.
Raise Not_found if the character does not appear in the string
ordinal_suffix n is the appropriate suffix to append to the numeral n as an ordinal number: 1 -> "st", 2 -> "nd", 3 -> "rd", 4 -> "th", and so on. Handles larger numbers (e.g., 42 -> "nd") and the numbers 11--13 (which all get "th") correctly.
module Color : sig ... endmodule Error_style : sig ... endnormalise_eol s returns a fresh copy of s with any '\r' characters removed. Intended for pre-processing text which will subsequently be printed on a channel which performs EOL transformations (i.e. Windows)
delete_eol_spaces s returns a fresh copy of s with any end of line spaces removed. Intended to normalize the output of the toplevel for tests.
val pp_two_columns :
+ ?sep:string ->
+ ?max_lines:int ->
+ Stdlib.Format.formatter ->
+ (string * string) list ->
+ unitpp_two_columns ?sep ?max_lines ppf l prints the lines in l as two columns separated by sep ("|" by default). max_lines can be used to indicate a maximum number of lines to print -- an ellipsis gets inserted at the middle if the input has too many lines.
Example:
pp_two_columns ~max_lines:3 Format.std_formatter [ + "abc", "hello"; + "def", "zzz"; + "a" , "bllbl"; + "bb" , "dddddd"; + ]
prints
abc | hello + ... + bb | dddddd
val get_build_path_prefix_map : unit -> Build_path_prefix_map.map optionReturns the map encoded in the BUILD_PATH_PREFIX_MAP environment variable.
Returns the list of --debug-prefix-map flags to be passed to the assembler, built from the BUILD_PATH_PREFIX_MAP environment variable.
val print_if :
+ Stdlib.Format.formatter ->
+ bool ref ->
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a ->
+ 'aprint_if ppf flag fmt x prints x with fmt on ppf if b is true.
type crcs = (modname * Stdlib.Digest.t option) listtype alerts = string Stdlib.String.Map.tmodule Magic_number : sig ... enda typical magic number is "Caml1999I011"; it is formed of an alphanumeric prefix, here Caml1990I, followed by a version, here 011. The prefix identifies the kind of the versioned data: here the I indicates that it is the magic number for .cmi files.
Mtypeval scrape : Env.t -> Types.module_type -> Types.module_typeval scrape_for_functor_arg : Env.t -> Types.module_type -> Types.module_typeval scrape_for_type_of :
+ remove_aliases:bool ->
+ Env.t ->
+ Types.module_type ->
+ Types.module_typeval freshen : scope:int -> Types.module_type -> Types.module_typeval strengthen :
+ aliasable:bool ->
+ Env.t ->
+ Types.module_type ->
+ Path.t ->
+ Types.module_typeval strengthen_decl :
+ aliasable:bool ->
+ Env.t ->
+ Types.module_declaration ->
+ Path.t ->
+ Types.module_declarationval nondep_supertype :
+ Env.t ->
+ Ident.t list ->
+ Types.module_type ->
+ Types.module_typeval nondep_sig_item :
+ Env.t ->
+ Ident.t list ->
+ Types.signature_item ->
+ Types.signature_itemval no_code_needed : Env.t -> Types.module_type -> boolval no_code_needed_sig : Env.t -> Types.signature -> boolval enrich_modtype : Env.t -> Path.t -> Types.module_type -> Types.module_typeval enrich_typedecl :
+ Env.t ->
+ Path.t ->
+ Ident.t ->
+ Types.type_declaration ->
+ Types.type_declarationval type_paths : Env.t -> Path.t -> Types.module_type -> Path.t listval contains_type : Env.t -> Types.module_type -> boolval lower_nongen : int -> Types.module_type -> unitMutable_variable.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitMutable_variable.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringMutable_variable.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitMutable_variable.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tMutable_variableinclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create :
+ ?current_compilation_unit:Compilation_unit.t ->
+ Internal_variable_names.t ->
+ tval create_from_variable :
+ ?current_compilation_unit:Compilation_unit.t ->
+ Variable.t ->
+ tval rename : ?current_compilation_unit:Compilation_unit.t -> t -> tval in_compilation_unit : t -> Compilation_unit.t -> boolval name : t -> stringval unique_name : t -> stringval print_list : Stdlib.Format.formatter -> t list -> unitval print_opt : Stdlib.Format.formatter -> t option -> unitval output_full : out_channel -> t -> unitMutexLocks for mutual exclusion.
Mutexes (mutual-exclusion locks) are used to implement critical sections and protect shared mutable data structures against concurrent accesses. The typical use is (if m is the mutex associated with the data structure D):
Mutex.lock m;
+(* Critical section that operates over D *);
+Mutex.unlock mval create : unit -> tReturn a new mutex.
val lock : t -> unitLock the given mutex. Only one thread can have the mutex locked at any time. A thread that attempts to lock a mutex already locked by another thread will suspend until the other thread unlocks the mutex.
val try_lock : t -> boolSame as Mutex.lock, but does not suspend the calling thread if the mutex is already locked: just return false immediately in that case. If the mutex is unlocked, lock it and return true.
val unlock : t -> unitUnlock the given mutex. Other threads suspended trying to lock the mutex will restart. The mutex must have been previously locked by the thread that calls Mutex.unlock.
Float.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitFloat.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringFloat.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitFloat.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tNumbers.Floatmodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := TInt.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitInt.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringInt.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitInt.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tNumbers.Intinclude Identifiable.S with type t = intmodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval zero_to_n : int -> Set.tzero_to_n n is the set of numbers {0, ..., n} (inclusive).
Numbers.Int16Numbers.Int8NumbersModules about numbers, some of which satisfy Identifiable.S.
Warning: this module is unstable and part of compiler-libs.
module Int : sig ... endmodule Int8 : sig ... endmodule Int16 : sig ... endmodule Float : Identifiable.S with type t = floatOdocmodule M = Odoc_messagesval loaded_modules : Odoc_module.t_module listval modules : Odoc_module.t_module listOdoc_analyseval analyse_files :
+ ?init:Odoc_module.t_module list ->
+ Odoc_global.source_file list ->
+ Odoc_module.t_module listval dump_modules : string -> Odoc_module.t_module list -> unitval load_modules : string -> Odoc_module.t_module listOdoc_argsval current_generator : Odoc_gen.generator option refval set_generator : Odoc_gen.generator -> unitval extend_html_generator : (module Odoc_gen.Html_functor) -> unitval extend_latex_generator : (module Odoc_gen.Latex_functor) -> unitval extend_texi_generator : (module Odoc_gen.Texi_functor) -> unitval extend_man_generator : (module Odoc_gen.Man_functor) -> unitval extend_dot_generator : (module Odoc_gen.Dot_functor) -> unitval extend_base_generator : (module Odoc_gen.Base_functor) -> unitval add_option : (string * Stdlib.Arg.spec * string) -> unitAnalyser._val all_special : string -> string -> int * Odoc_types.info listval just_after_special : string -> string -> int * Odoc_types.info optionval first_special : string -> string -> int * Odoc_types.info optionval get_comments :
+ (Odoc_types.text -> 'a) ->
+ string ->
+ string ->
+ Odoc_types.info option * 'a listOdoc_ast.Analysermodule _ : Odoc_sig.Info_retrieverval analyse_typed_tree :
+ string ->
+ string ->
+ Parsetree.structure ->
+ typedtree ->
+ Odoc_module.t_moduleOdoc_ast.Typedtree_searchtype tab = (ele, Typedtree.structure_item_desc) Stdlib.Hashtbl.ttype tab_values =
+ (Odoc_name.t, Typedtree.pattern * Typedtree.expression) Stdlib.Hashtbl.tval tables : Typedtree.structure_item list -> tab * tab_valuesval search_module : tab -> string -> Typedtree.module_exprval search_module_type : tab -> string -> Typedtree.module_type_declarationval search_extension : tab -> string -> Typedtree.type_extensionval search_type_declaration : tab -> string -> Typedtree.type_declarationval search_class_exp :
+ tab ->
+ string ->
+ Typedtree.class_expr * Types.type_expr listval search_class_type_declaration :
+ tab ->
+ string ->
+ Typedtree.class_type_declarationval search_value :
+ tab_values ->
+ string ->
+ Typedtree.pattern * Typedtree.expressionval search_primitive : tab -> string -> Types.type_exprval get_nth_inherit_class_expr :
+ Typedtree.class_structure ->
+ int ->
+ Typedtree.class_exprval search_attribute_type :
+ Typedtree.class_structure ->
+ string ->
+ Types.type_exprval search_method_expression :
+ Typedtree.class_structure ->
+ string ->
+ Typedtree.expressionOdoc_asttype typedtree = Typedtree.structure * Typedtree.module_coercionmodule Typedtree_search : sig ... endmodule Analyser (_ : Odoc_sig.Info_retriever) : sig ... endOdoc_classmodule Name = Odoc_nametype class_element = | Class_attribute of Odoc_value.t_attribute| Class_method of Odoc_value.t_method| Class_comment of Odoc_types.textand inherited_class = {ic_name : Name.t;mutable ic_class : cct option;ic_text : Odoc_types.text option;}and class_apply = {capp_name : Name.t;mutable capp_class : t_class option;capp_params : Types.type_expr list;capp_params_code : string list;}and class_constr = {cco_name : Name.t;mutable cco_class : cct option;cco_type_parameters : Types.type_expr list;}and class_kind = | Class_structure of inherited_class list * class_element list| Class_apply of class_apply| Class_constr of class_constr| Class_constraint of class_kind * class_type_kindand t_class = {cl_name : Name.t;mutable cl_info : Odoc_types.info option;cl_type : Types.class_type;cl_type_parameters : Types.type_expr list;cl_virtual : bool;mutable cl_kind : class_kind;mutable cl_parameters : Odoc_parameter.parameter list;mutable cl_loc : Odoc_types.location;}and class_type_alias = {cta_name : Name.t;mutable cta_class : cct option;cta_type_parameters : Types.type_expr list;}and class_type_kind = | Class_signature of inherited_class list * class_element list| Class_type of class_type_aliasand t_class_type = {clt_name : Name.t;mutable clt_info : Odoc_types.info option;clt_type : Types.class_type;clt_type_parameters : Types.type_expr list;clt_virtual : bool;mutable clt_kind : class_type_kind;mutable clt_loc : Odoc_types.location;}val class_parameter_text_by_name : t_class -> string -> Odoc_types.text optionval class_elements : ?trans:bool -> t_class -> class_element listval class_type_elements : ?trans:bool -> t_class_type -> class_element listval class_attributes : ?trans:bool -> t_class -> Odoc_value.t_attribute listval class_methods : ?trans:bool -> t_class -> Odoc_value.t_method listval class_comments : ?trans:bool -> t_class -> Odoc_types.text listval class_update_parameters_text : t_class -> unitval class_type_attributes :
+ ?trans:bool ->
+ t_class_type ->
+ Odoc_value.t_attribute listval class_type_methods :
+ ?trans:bool ->
+ t_class_type ->
+ Odoc_value.t_method listval class_type_comments : ?trans:bool -> t_class_type -> Odoc_types.text listval class_type_parameter_text_by_name :
+ t_class_type ->
+ string ->
+ Odoc_types.text optionOdoc_comments.Basic_info_retrieverval all_special : string -> string -> int * Odoc_types.info listval just_after_special : string -> string -> int * Odoc_types.info optionval first_special : string -> string -> int * Odoc_types.info optionval get_comments :
+ (Odoc_types.text -> 'a) ->
+ string ->
+ string ->
+ Odoc_types.info option * 'a listOdoc_commentsmodule type Texter = sig ... endmodule Basic_info_retriever : sig ... endval info_of_string : string -> Odoc_types.infoval info_of_comment_file :
+ Odoc_module.t_module list ->
+ string ->
+ Odoc_types.infoOdoc_comments.Texterval text_of_string : string -> Odoc_types.textOdoc_comments_globalval nb_chars : int refval authors : string list refval version : string option refval sees : string list refval since : string option refval before : (string * string) list refval deprecated : string option refval params : (string * string) list refval raised_exceptions : (string * string) list refval return_value : string option refval customs : (string * string) list refOdoc_configval print_warnings : bool refOdoc_controlOdoc_crossval associate : Odoc_module.t_module list -> unitval assoc_comments_info :
+ string ->
+ Odoc_module.t_module list ->
+ Odoc_types.info ->
+ Odoc_types.infoOdoc_dag2htmlval html_of_dag : string dag -> stringval create_class_dag :
+ Odoc_info.Class.t_class list ->
+ Odoc_info.Class.t_class_type list ->
+ (Odoc_info.Name.t * Odoc_info.Class.cct option) dagOdoc_dep.Depval set_to_list : String.Set.t -> String.Set.elt listtype node = {id : id;mutable near : String.Set.t;mutable far : (id * String.Set.t) list;reflex : bool;}type graph = node listval trans_closure : node list -> String.Set.t -> node -> String.Set.tval compute_trans_closure : node list -> unitOdoc_depmodule Module = Odoc_modulemodule Type = Odoc_typemodule String = Misc.Stdlib.Stringval set_to_list : String.Set.t -> String.Set.elt listval impl_dependencies : Parsetree.structure -> String.Set.elt listval intf_dependencies : Parsetree.signature -> String.Set.elt listmodule Dep : sig ... endval type_deps : Odoc_type.t_type -> string listval kernel_deps_of_modules : Module.t_module list -> unitval deps_of_types :
+ ?kernel:bool ->
+ Type.t_type list ->
+ (Type.t_type * String.Set.elt list) listGenerator.dotval mutable modules : Odoc_info.Module.t_module listval mutable loc_colors : (Odoc_info.Name.t * string) listmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_module : F.formatter -> Odoc_info.Module.t_module -> unitmethod generate_for_type : F.formatter ->
+ (Odoc_info.Type.t_type * Odoc_info.Name.t list) ->
+ unitmethod generate_modules : Odoc_info.Module.t_module list -> unitmethod generate_types : Odoc_info.Type.t_type list -> unitmethod node_color : Odoc_info.Name.t -> string optionmethod print_module_atts : F.formatter -> Odoc_info.Module.t_module -> unitmethod print_one_dep : F.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ unitmethod print_type_atts : F.formatter -> Odoc_info.Type.t_type -> unitOdoc_dot.Generatorclass dot : object ... endOdoc_dotmodule F = Stdlib.Formatval dot_include_all : bool refval dot_types : bool refval dot_reduce : bool refval dot_colors : string list refmodule Generator : sig ... endmodule type Dot_generator = sig ... endDot_generator.dotval mutable modules : Odoc_info.Module.t_module listval mutable loc_colors : (Odoc_info.Name.t * string) listmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_module : F.formatter -> Odoc_info.Module.t_module -> unitmethod generate_for_type : F.formatter ->
+ (Odoc_info.Type.t_type * Odoc_info.Name.t list) ->
+ unitmethod generate_modules : Odoc_info.Module.t_module list -> unitmethod generate_types : Odoc_info.Type.t_type list -> unitmethod node_color : Odoc_info.Name.t -> string optionmethod print_module_atts : F.formatter -> Odoc_info.Module.t_module -> unitmethod print_one_dep : F.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ unitmethod print_type_atts : F.formatter -> Odoc_info.Type.t_type -> unitOdoc_dot.Dot_generatorclass dot : object ... endOdoc_envval empty : envval add_signature : env -> string -> ?rel:string -> Types.signature -> envval add_extension : env -> Odoc_name.t -> envval add_type : env -> Odoc_name.t -> envval add_value : env -> Odoc_name.t -> envval add_module : env -> Odoc_name.t -> envval add_module_type : env -> Odoc_name.t -> envval add_class : env -> Odoc_name.t -> envval add_class_type : env -> Odoc_name.t -> envval full_module_name : env -> Odoc_name.t -> Odoc_name.tval full_module_type_name : env -> Odoc_name.t -> Odoc_name.tval full_module_or_module_type_name : env -> Odoc_name.t -> Odoc_name.tval full_type_name : env -> Odoc_name.t -> Odoc_name.tval full_value_name : env -> Odoc_name.t -> Odoc_name.tval full_extension_constructor_name : env -> Odoc_name.t -> Odoc_name.tval full_class_name : env -> Odoc_name.t -> Odoc_name.tval full_class_type_name : env -> Odoc_name.t -> Odoc_name.tval full_class_or_class_type_name : env -> Odoc_name.t -> Odoc_name.tval subst_type : env -> Types.type_expr -> Types.type_exprval subst_module_type : env -> Types.module_type -> Types.module_typeval subst_class_type : env -> Types.class_type -> Types.class_typeOdoc_exceptionmodule Name = Odoc_nameand t_exception = {ex_name : Name.t;mutable ex_info : Odoc_types.info option;ex_args : Odoc_type.constructor_args;ex_ret : Types.type_expr option;ex_alias : exception_alias option;mutable ex_loc : Odoc_types.location;mutable ex_code : string option;}Odoc_extensionmodule Name = Odoc_nameand t_extension_constructor = {xt_name : Name.t;xt_args : Odoc_type.constructor_args;xt_ret : Types.type_expr option;xt_type_extension : t_type_extension;xt_alias : extension_alias option;mutable xt_loc : Odoc_types.location;mutable xt_text : Odoc_types.info option;}and t_type_extension = {mutable te_info : Odoc_types.info option;te_type_name : Name.t;te_type_parameters : Types.type_expr list;te_private : private_flag;mutable te_constructors : t_extension_constructor list;mutable te_loc : Odoc_types.location;mutable te_code : string option;}val extension_constructors : t_type_extension -> t_extension_constructor listBase_generator.generatormethod generate : Odoc_module.t_module list -> unitOdoc_gen.Base_generatorclass generator : doc_generatorOdoc_gen.doc_generatormethod generate : Odoc_module.t_module list -> unitOdoc_genclass type doc_generator = object ... endmodule type Base = sig ... endmodule Base_generator : Basemodule type Base_functor = functor (_ : Base) -> Basemodule type Html_functor =
+ functor (_ : Odoc_html.Html_generator) ->
+ Odoc_html.Html_generatormodule type Latex_functor =
+ functor (_ : Odoc_latex.Latex_generator) ->
+ Odoc_latex.Latex_generatormodule type Texi_functor =
+ functor (_ : Odoc_texi.Texi_generator) ->
+ Odoc_texi.Texi_generatormodule type Man_functor =
+ functor (_ : Odoc_man.Man_generator) ->
+ Odoc_man.Man_generatormodule type Dot_functor =
+ functor (_ : Odoc_dot.Dot_generator) ->
+ Odoc_dot.Dot_generatortype generator = | Html of (module Odoc_html.Html_generator)| Latex of (module Odoc_latex.Latex_generator)| Texi of (module Odoc_texi.Texi_generator)| Man of (module Odoc_man.Man_generator)| Dot of (module Odoc_dot.Dot_generator)| Base of (module Base)val get_minimal_generator : generator -> doc_generatorBase.generatormethod generate : Odoc_module.t_module list -> unitOdoc_gen.Baseclass generator : doc_generator_.generatormethod generate : Odoc_module.t_module list -> unitBase_functor._class generator : doc_generatorBase_functor.generatormethod generate : Odoc_module.t_module list -> unitOdoc_gen.Base_functor_.dotval mutable modules : Odoc_info.Module.t_module listval mutable loc_colors : (Odoc_info.Name.t * string) listmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_module : Odoc_dot.F.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_for_type : Odoc_dot.F.formatter ->
+ (Odoc_info.Type.t_type * Odoc_info.Name.t list) ->
+ unitmethod generate_modules : Odoc_info.Module.t_module list -> unitmethod generate_types : Odoc_info.Type.t_type list -> unitmethod node_color : Odoc_info.Name.t -> string optionmethod print_module_atts : Odoc_dot.F.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod print_one_dep : Odoc_dot.F.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ unitmethod print_type_atts : Odoc_dot.F.formatter -> Odoc_info.Type.t_type -> unitDot_functor._class dot : object ... endDot_functor.dotval mutable modules : Odoc_info.Module.t_module listval mutable loc_colors : (Odoc_info.Name.t * string) listmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_module : Odoc_dot.F.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_for_type : Odoc_dot.F.formatter ->
+ (Odoc_info.Type.t_type * Odoc_info.Name.t list) ->
+ unitmethod generate_modules : Odoc_info.Module.t_module list -> unitmethod generate_types : Odoc_info.Type.t_type list -> unitmethod node_color : Odoc_info.Name.t -> string optionmethod print_module_atts : Odoc_dot.F.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod print_one_dep : Odoc_dot.F.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ unitmethod print_type_atts : Odoc_dot.F.formatter -> Odoc_info.Type.t_type -> unitOdoc_gen.Dot_functor_.htmlval mutable tag_functions : (string * (Odoc_info.text -> string)) listval mutable list_values : Odoc_info.Value.t_value listval mutable list_types : Odoc_info.Type.t_type listval mutable list_modules : Odoc_info.Module.t_module listval mutable list_module_types : Odoc_info.Module.t_module_type listval mutable list_methods : Odoc_info.Value.t_method listval mutable list_extensions : Odoc_info.Extension.t_extension_constructor listval mutable list_exceptions : Odoc_info.Exception.t_exception listval mutable list_classes : Odoc_info.Class.t_class listval mutable list_class_types : Odoc_info.Class.t_class_type listval mutable list_attributes : Odoc_info.Value.t_attribute listval mutable known_types_names : Odoc_html.String.Set.tval mutable known_modules_names : Odoc_html.String.Set.tval mutable known_classes_names : Odoc_html.String.Set.tval mutable header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitmethod character_encoding : Buffer.t -> unitmethod create_fully_qualified_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_fully_qualified_module_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_title_label : (int * string option * Odoc_info.text) -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_attributes_index : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_class_types_index : Odoc_info.Module.t_module list -> unitmethod generate_classes_index : Odoc_info.Module.t_module list -> unitmethod generate_elements_index : 'a. ?strip_libname:bool ->
+ 'a list ->
+ ('a -> Odoc_info.Name.t) ->
+ ('a -> Odoc_info.info option) ->
+ ('a -> string) ->
+ string ->
+ string ->
+ unitmethod generate_exceptions_index : Odoc_info.Module.t_module list -> unitmethod generate_extensions_index : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_for_class_type : Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_for_module_type : Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_index : Odoc_info.Module.t_module list -> unitmethod generate_inheritance_info : Buffer.t ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_methods_index : Odoc_info.Module.t_module list -> unitmethod generate_module_types_index : Odoc_info.Module.t_module list -> unitmethod generate_modules_index : Odoc_info.Module.t_module list -> unitmethod generate_types_index : Odoc_info.Module.t_module list -> unitmethod generate_values_index : Odoc_info.Module.t_module list -> unitmethod html_of_Block : Buffer.t -> Odoc_info.text -> unitmethod html_of_Bold : Buffer.t -> Odoc_info.text -> unitmethod html_of_Center : Buffer.t -> Odoc_info.text -> unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Emphasize : Buffer.t -> Odoc_info.text -> unitmethod html_of_Enum : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Index_list : Buffer.t -> unitmethod html_of_Italic : Buffer.t -> Odoc_info.text -> unitmethod html_of_Latex : Buffer.t -> string -> unitmethod html_of_Left : Buffer.t -> Odoc_info.text -> unitmethod html_of_Link : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_List : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Module_list : Buffer.t -> Odoc_info.Name.t list -> unitmethod html_of_Newline : Buffer.t -> unitmethod html_of_Raw : Buffer.t -> string -> unitmethod html_of_Ref : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod html_of_Right : Buffer.t -> Odoc_info.text -> unitmethod html_of_Subscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Superscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Target : Buffer.t -> target:string -> code:string -> unitmethod html_of_Title : Buffer.t ->
+ int ->
+ string option ->
+ Odoc_info.text ->
+ unitmethod html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod html_of_author_list : Buffer.t -> string list -> unitmethod html_of_before : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_class : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_class_element : Buffer.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod html_of_class_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?cl:Odoc_info.Class.t_class ->
+ Odoc_info.Class.class_kind ->
+ unitmethod html_of_class_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_type : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod html_of_class_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?ct:Odoc_info.Class.t_class_type ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod html_of_class_type_param_expr_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr list ->
+ unitmethod html_of_code : Buffer.t -> ?with_pre:bool -> string -> unitmethod html_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod html_of_custom : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_dag : (Odoc_info.Name.t * Odoc_info.Class.cct option)
+ Odoc_dag2html.dag ->
+ stringmethod html_of_described_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod html_of_included_module : Buffer.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod html_of_info : ?cls:string ->
+ ?indent:bool ->
+ Buffer.t ->
+ Odoc_types.info option ->
+ unitmethod html_of_info_first_sentence : Buffer.t -> Odoc_info.info option -> unitmethod html_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod html_of_modtype : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod html_of_module : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module ->
+ unitmethod html_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_module_element : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod html_of_module_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ Odoc_info.Module.module_kind ->
+ unitmethod html_of_module_parameter : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod html_of_module_parameter_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_type : Buffer.t ->
+ ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod html_of_module_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ ?mt:Odoc_info.Module.t_module_type ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod html_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod html_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_raised_exceptions : Buffer.t ->
+ (string * Odoc_info.text) list ->
+ unitmethod html_of_record : father:Odoc_info.Name.t ->
+ close_env:string ->
+ (Odoc_info.Type.record_field -> string) ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod html_of_return_opt : Buffer.t -> Odoc_info.text option -> unitmethod html_of_see : Buffer.t -> (Odoc_info.see_ref * Odoc_info.text) -> unitmethod html_of_sees : Buffer.t ->
+ (Odoc_info.see_ref * Odoc_info.text) list ->
+ unitmethod html_of_since_opt : Buffer.t -> string option -> unitmethod html_of_text : ?with_p:bool -> Buffer.t -> Odoc_info.text -> unitmethod html_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod html_of_text_with_p : Buffer.t -> Odoc_info.text -> unitmethod html_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod html_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod html_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod html_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod html_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod html_of_version_opt : Buffer.t -> string option -> unitmethod html_sections_links : Buffer.t -> Odoc_info.text list -> unitmethod inner_title : Odoc_info.Name.t -> stringmethod label_of_text : Odoc_info.text -> stringmethod list_attributes : Odoc_info.Value.t_attribute listmethod list_class_types : Odoc_info.Class.t_class_type listmethod list_classes : Odoc_info.Class.t_class listmethod list_exceptions : Odoc_info.Exception.t_exception listmethod list_extensions : Odoc_info.Extension.t_extension_constructor listmethod list_methods : Odoc_info.Value.t_method listmethod list_module_types : Odoc_info.Module.t_module_type listmethod list_modules : Odoc_info.Module.t_module listmethod list_types : Odoc_info.Type.t_type listmethod list_values : Odoc_info.Value.t_value listmethod meta : Buffer.t -> unitmethod output_class_type : Odoc_info.Name.t ->
+ string ->
+ Types.class_type ->
+ unitmethod output_module_type : Odoc_info.Name.t ->
+ string ->
+ Types.module_type ->
+ unitmethod prepare_header : Odoc_info.Module.t_module list -> unitmethod print_header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitHtml_functor._class html : object ... endHtml_functor.htmlval mutable tag_functions : (string * (Odoc_info.text -> string)) listval mutable list_values : Odoc_info.Value.t_value listval mutable list_types : Odoc_info.Type.t_type listval mutable list_modules : Odoc_info.Module.t_module listval mutable list_module_types : Odoc_info.Module.t_module_type listval mutable list_methods : Odoc_info.Value.t_method listval mutable list_extensions : Odoc_info.Extension.t_extension_constructor listval mutable list_exceptions : Odoc_info.Exception.t_exception listval mutable list_classes : Odoc_info.Class.t_class listval mutable list_class_types : Odoc_info.Class.t_class_type listval mutable list_attributes : Odoc_info.Value.t_attribute listval mutable known_types_names : Odoc_html.String.Set.tval mutable known_modules_names : Odoc_html.String.Set.tval mutable known_classes_names : Odoc_html.String.Set.tval mutable header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitmethod character_encoding : Buffer.t -> unitmethod create_fully_qualified_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_fully_qualified_module_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_title_label : (int * string option * Odoc_info.text) -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_attributes_index : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_class_types_index : Odoc_info.Module.t_module list -> unitmethod generate_classes_index : Odoc_info.Module.t_module list -> unitmethod generate_elements_index : 'a. ?strip_libname:bool ->
+ 'a list ->
+ ('a -> Odoc_info.Name.t) ->
+ ('a -> Odoc_info.info option) ->
+ ('a -> string) ->
+ string ->
+ string ->
+ unitmethod generate_exceptions_index : Odoc_info.Module.t_module list -> unitmethod generate_extensions_index : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_for_class_type : Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_for_module_type : Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_index : Odoc_info.Module.t_module list -> unitmethod generate_inheritance_info : Buffer.t ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_methods_index : Odoc_info.Module.t_module list -> unitmethod generate_module_types_index : Odoc_info.Module.t_module list -> unitmethod generate_modules_index : Odoc_info.Module.t_module list -> unitmethod generate_types_index : Odoc_info.Module.t_module list -> unitmethod generate_values_index : Odoc_info.Module.t_module list -> unitmethod html_of_Block : Buffer.t -> Odoc_info.text -> unitmethod html_of_Bold : Buffer.t -> Odoc_info.text -> unitmethod html_of_Center : Buffer.t -> Odoc_info.text -> unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Emphasize : Buffer.t -> Odoc_info.text -> unitmethod html_of_Enum : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Index_list : Buffer.t -> unitmethod html_of_Italic : Buffer.t -> Odoc_info.text -> unitmethod html_of_Latex : Buffer.t -> string -> unitmethod html_of_Left : Buffer.t -> Odoc_info.text -> unitmethod html_of_Link : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_List : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Module_list : Buffer.t -> Odoc_info.Name.t list -> unitmethod html_of_Newline : Buffer.t -> unitmethod html_of_Raw : Buffer.t -> string -> unitmethod html_of_Ref : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod html_of_Right : Buffer.t -> Odoc_info.text -> unitmethod html_of_Subscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Superscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Target : Buffer.t -> target:string -> code:string -> unitmethod html_of_Title : Buffer.t ->
+ int ->
+ string option ->
+ Odoc_info.text ->
+ unitmethod html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod html_of_author_list : Buffer.t -> string list -> unitmethod html_of_before : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_class : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_class_element : Buffer.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod html_of_class_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?cl:Odoc_info.Class.t_class ->
+ Odoc_info.Class.class_kind ->
+ unitmethod html_of_class_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_type : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod html_of_class_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?ct:Odoc_info.Class.t_class_type ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod html_of_class_type_param_expr_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr list ->
+ unitmethod html_of_code : Buffer.t -> ?with_pre:bool -> string -> unitmethod html_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod html_of_custom : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_dag : (Odoc_info.Name.t * Odoc_info.Class.cct option)
+ Odoc_dag2html.dag ->
+ stringmethod html_of_described_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod html_of_included_module : Buffer.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod html_of_info : ?cls:string ->
+ ?indent:bool ->
+ Buffer.t ->
+ Odoc_types.info option ->
+ unitmethod html_of_info_first_sentence : Buffer.t -> Odoc_info.info option -> unitmethod html_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod html_of_modtype : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod html_of_module : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module ->
+ unitmethod html_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_module_element : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod html_of_module_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ Odoc_info.Module.module_kind ->
+ unitmethod html_of_module_parameter : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod html_of_module_parameter_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_type : Buffer.t ->
+ ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod html_of_module_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ ?mt:Odoc_info.Module.t_module_type ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod html_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod html_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_raised_exceptions : Buffer.t ->
+ (string * Odoc_info.text) list ->
+ unitmethod html_of_record : father:Odoc_info.Name.t ->
+ close_env:string ->
+ (Odoc_info.Type.record_field -> string) ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod html_of_return_opt : Buffer.t -> Odoc_info.text option -> unitmethod html_of_see : Buffer.t -> (Odoc_info.see_ref * Odoc_info.text) -> unitmethod html_of_sees : Buffer.t ->
+ (Odoc_info.see_ref * Odoc_info.text) list ->
+ unitmethod html_of_since_opt : Buffer.t -> string option -> unitmethod html_of_text : ?with_p:bool -> Buffer.t -> Odoc_info.text -> unitmethod html_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod html_of_text_with_p : Buffer.t -> Odoc_info.text -> unitmethod html_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod html_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod html_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod html_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod html_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod html_of_version_opt : Buffer.t -> string option -> unitmethod html_sections_links : Buffer.t -> Odoc_info.text list -> unitmethod inner_title : Odoc_info.Name.t -> stringmethod label_of_text : Odoc_info.text -> stringmethod list_attributes : Odoc_info.Value.t_attribute listmethod list_class_types : Odoc_info.Class.t_class_type listmethod list_classes : Odoc_info.Class.t_class listmethod list_exceptions : Odoc_info.Exception.t_exception listmethod list_extensions : Odoc_info.Extension.t_extension_constructor listmethod list_methods : Odoc_info.Value.t_method listmethod list_module_types : Odoc_info.Module.t_module_type listmethod list_modules : Odoc_info.Module.t_module listmethod list_types : Odoc_info.Type.t_type listmethod list_values : Odoc_info.Value.t_value listmethod meta : Buffer.t -> unitmethod output_class_type : Odoc_info.Name.t ->
+ string ->
+ Types.class_type ->
+ unitmethod output_module_type : Odoc_info.Name.t ->
+ string ->
+ Types.module_type ->
+ unitmethod prepare_header : Odoc_info.Module.t_module list -> unitmethod print_header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitOdoc_gen.Html_functor_.latexval mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval subst_strings_simple : (Str.regexp * string) listval subst_strings_code : (Str.regexp * string) listval subst_strings : (Str.regexp * string) listmethod attribute_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod const_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod entry_comment : (Format.formatter * (unit -> string)) ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod exception_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod extension_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod first_and_rest_of_info : Odoc_info.info option ->
+ Odoc_info.text * Odoc_info.textmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_top_module : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_inheritance_info : Format.formatter ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod label : ?no_:bool -> Odoc_info.Name.t -> stringmethod latex_for_class_index : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_label : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_type_index : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_class_type_label : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_module_index : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_label : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_type_index : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_for_module_type_label : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_header : Format.formatter ->
+ Odoc_info.Module.t_module list ->
+ unitmethod latex_of_Block : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Bold : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Center : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Code : Format.formatter -> string -> unitmethod latex_of_CodePre : Format.formatter -> string -> unitmethod latex_of_Emphasize : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Enum : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Italic : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Latex : Format.formatter -> string -> unitmethod latex_of_Left : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Link : Format.formatter -> string -> Odoc_info.text -> unitmethod latex_of_List : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Newline : Format.formatter -> unitmethod latex_of_Raw : Format.formatter -> string -> unitmethod latex_of_Ref : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod latex_of_Right : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Subscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Superscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Target : Format.formatter ->
+ target:string ->
+ code:string ->
+ unitmethod latex_of_Title : Format.formatter ->
+ int ->
+ Odoc_info.Name.t option ->
+ Odoc_info.text ->
+ unitmethod latex_of_Verbatim : Format.formatter -> string -> unitmethod latex_of_attribute : Format.formatter ->
+ Odoc_info.Value.t_attribute ->
+ unitmethod latex_of_class : Format.formatter -> Odoc_info.Class.t_class -> unitmethod latex_of_class_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod latex_of_class_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ unitmethod latex_of_class_parameter_list : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_of_class_type : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_of_class_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod latex_of_cstr_args : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Type.constructor_args * Types.type_expr option) ->
+ Odoc_info.text_element listmethod latex_of_custom_text : Format.formatter ->
+ string ->
+ Odoc_info.text ->
+ unitmethod latex_of_exception : Format.formatter ->
+ Odoc_info.Exception.t_exception ->
+ unitmethod latex_of_included_module : Format.formatter ->
+ Odoc_info.Module.included_module ->
+ unitmethod latex_of_info : Format.formatter ->
+ ?block:bool ->
+ Odoc_info.info option ->
+ unitmethod latex_of_method : Format.formatter -> Odoc_info.Value.t_method -> unitmethod latex_of_module : Format.formatter -> Odoc_info.Module.t_module -> unitmethod latex_of_module_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod latex_of_module_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_kind ->
+ unitmethod latex_of_module_parameter : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod latex_of_module_type : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_of_module_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod latex_of_record : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field list ->
+ Odoc_info.text_element listmethod latex_of_text : Format.formatter -> Odoc_info.text -> unitmethod latex_of_text_element : Format.formatter ->
+ Odoc_info.text_element ->
+ unitmethod latex_of_type : Format.formatter -> Odoc_info.Type.t_type -> unitmethod latex_of_type_extension : Odoc_info.Name.t ->
+ Format.formatter ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod latex_of_type_params : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod latex_of_value : Format.formatter -> Odoc_info.Value.t_value -> unitmethod method_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod recfield_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod subst : (Str.regexp * string) list -> string -> stringmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool -> Odoc_info.info option -> Odoc_info.textmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listmethod type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod value_label : ?no_:bool -> Odoc_info.Name.t -> stringLatex_functor._class latex : object ... endLatex_functor.latexval mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval subst_strings_simple : (Str.regexp * string) listval subst_strings_code : (Str.regexp * string) listval subst_strings : (Str.regexp * string) listmethod attribute_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod const_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod entry_comment : (Format.formatter * (unit -> string)) ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod exception_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod extension_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod first_and_rest_of_info : Odoc_info.info option ->
+ Odoc_info.text * Odoc_info.textmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_top_module : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_inheritance_info : Format.formatter ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod label : ?no_:bool -> Odoc_info.Name.t -> stringmethod latex_for_class_index : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_label : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_type_index : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_class_type_label : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_module_index : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_label : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_type_index : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_for_module_type_label : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_header : Format.formatter ->
+ Odoc_info.Module.t_module list ->
+ unitmethod latex_of_Block : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Bold : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Center : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Code : Format.formatter -> string -> unitmethod latex_of_CodePre : Format.formatter -> string -> unitmethod latex_of_Emphasize : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Enum : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Italic : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Latex : Format.formatter -> string -> unitmethod latex_of_Left : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Link : Format.formatter -> string -> Odoc_info.text -> unitmethod latex_of_List : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Newline : Format.formatter -> unitmethod latex_of_Raw : Format.formatter -> string -> unitmethod latex_of_Ref : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod latex_of_Right : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Subscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Superscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Target : Format.formatter ->
+ target:string ->
+ code:string ->
+ unitmethod latex_of_Title : Format.formatter ->
+ int ->
+ Odoc_info.Name.t option ->
+ Odoc_info.text ->
+ unitmethod latex_of_Verbatim : Format.formatter -> string -> unitmethod latex_of_attribute : Format.formatter ->
+ Odoc_info.Value.t_attribute ->
+ unitmethod latex_of_class : Format.formatter -> Odoc_info.Class.t_class -> unitmethod latex_of_class_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod latex_of_class_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ unitmethod latex_of_class_parameter_list : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_of_class_type : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_of_class_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod latex_of_cstr_args : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Type.constructor_args * Types.type_expr option) ->
+ Odoc_info.text_element listmethod latex_of_custom_text : Format.formatter ->
+ string ->
+ Odoc_info.text ->
+ unitmethod latex_of_exception : Format.formatter ->
+ Odoc_info.Exception.t_exception ->
+ unitmethod latex_of_included_module : Format.formatter ->
+ Odoc_info.Module.included_module ->
+ unitmethod latex_of_info : Format.formatter ->
+ ?block:bool ->
+ Odoc_info.info option ->
+ unitmethod latex_of_method : Format.formatter -> Odoc_info.Value.t_method -> unitmethod latex_of_module : Format.formatter -> Odoc_info.Module.t_module -> unitmethod latex_of_module_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod latex_of_module_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_kind ->
+ unitmethod latex_of_module_parameter : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod latex_of_module_type : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_of_module_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod latex_of_record : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field list ->
+ Odoc_info.text_element listmethod latex_of_text : Format.formatter -> Odoc_info.text -> unitmethod latex_of_text_element : Format.formatter ->
+ Odoc_info.text_element ->
+ unitmethod latex_of_type : Format.formatter -> Odoc_info.Type.t_type -> unitmethod latex_of_type_extension : Odoc_info.Name.t ->
+ Format.formatter ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod latex_of_type_params : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod latex_of_value : Format.formatter -> Odoc_info.Value.t_value -> unitmethod method_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod recfield_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod subst : (Str.regexp * string) list -> string -> stringmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool -> Odoc_info.info option -> Odoc_info.textmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listmethod type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod value_label : ?no_:bool -> Odoc_info.Name.t -> stringOdoc_gen.Latex_functor_.manval mutable tag_functions : (string * (Odoc_info.text -> string)) listmethod create_groups : bool ->
+ Odoc_info.Module.t_module list ->
+ Odoc_info.Search.result_element list listmethod field_comment : Buffer.t -> Odoc_info.info option -> unitmethod file_name : Odoc_info.Name.t -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class -> unitmethod generate_for_class_type : Odoc_info.Class.t_class_type -> unitmethod generate_for_group : Odoc_info.Search.result_element list -> unitmethod generate_for_module : Odoc_info.Module.t_module -> unitmethod generate_for_module_type : Odoc_info.Module.t_module_type -> unitmethod man_of_Target : Buffer.t -> target:string -> code:string -> unitmethod man_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod man_of_class : Buffer.t -> Odoc_info.Class.t_class -> unitmethod man_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_class_type : Buffer.t -> Odoc_info.Class.t_class_type -> unitmethod man_of_class_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.class_type ->
+ unitmethod man_of_code : Buffer.t -> string -> unitmethod man_of_const : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.variant_constructor ->
+ unitmethod man_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod man_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod man_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod man_of_included_module : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod man_of_info : ?margin:int -> Buffer.t -> Odoc_types.info option -> unitmethod man_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod man_of_modtype : Buffer.t -> Odoc_info.Module.t_module_type -> unitmethod man_of_module : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_body : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod man_of_module_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod man_of_module_type_body : Buffer.t ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod man_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod man_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ unitmethod man_of_recfield : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field ->
+ unitmethod man_of_record : Odoc_info.Name.t ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod man_of_text : Buffer.t -> Odoc_info.text -> unitmethod man_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod man_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod man_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod man_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod man_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod man_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod open_out : string -> out_channelmethod relative_idents : Odoc_info.Name.t -> Odoc_info.Name.t -> stringmethod str_man_of_before : (string * Odoc_info.text) list -> stringmethod str_man_of_custom : (string * Odoc_info.text) list -> string listmethod str_man_of_raised_exceptions : (string * Odoc_info.text) list -> stringmethod str_man_of_return_opt : Odoc_info.text option -> stringmethod str_man_of_see : (Odoc_info.see_ref * Odoc_info.text) -> stringmethod str_man_of_sees : (Odoc_info.see_ref * Odoc_info.text) list -> stringmethod str_man_of_text : Odoc_info.text -> stringMan_functor._class man : object ... endMan_functor.manval mutable tag_functions : (string * (Odoc_info.text -> string)) listmethod create_groups : bool ->
+ Odoc_info.Module.t_module list ->
+ Odoc_info.Search.result_element list listmethod field_comment : Buffer.t -> Odoc_info.info option -> unitmethod file_name : Odoc_info.Name.t -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class -> unitmethod generate_for_class_type : Odoc_info.Class.t_class_type -> unitmethod generate_for_group : Odoc_info.Search.result_element list -> unitmethod generate_for_module : Odoc_info.Module.t_module -> unitmethod generate_for_module_type : Odoc_info.Module.t_module_type -> unitmethod man_of_Target : Buffer.t -> target:string -> code:string -> unitmethod man_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod man_of_class : Buffer.t -> Odoc_info.Class.t_class -> unitmethod man_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_class_type : Buffer.t -> Odoc_info.Class.t_class_type -> unitmethod man_of_class_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.class_type ->
+ unitmethod man_of_code : Buffer.t -> string -> unitmethod man_of_const : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.variant_constructor ->
+ unitmethod man_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod man_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod man_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod man_of_included_module : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod man_of_info : ?margin:int -> Buffer.t -> Odoc_types.info option -> unitmethod man_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod man_of_modtype : Buffer.t -> Odoc_info.Module.t_module_type -> unitmethod man_of_module : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_body : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod man_of_module_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod man_of_module_type_body : Buffer.t ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod man_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod man_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ unitmethod man_of_recfield : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field ->
+ unitmethod man_of_record : Odoc_info.Name.t ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod man_of_text : Buffer.t -> Odoc_info.text -> unitmethod man_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod man_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod man_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod man_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod man_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod man_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod open_out : string -> out_channelmethod relative_idents : Odoc_info.Name.t -> Odoc_info.Name.t -> stringmethod str_man_of_before : (string * Odoc_info.text) list -> stringmethod str_man_of_custom : (string * Odoc_info.text) list -> string listmethod str_man_of_raised_exceptions : (string * Odoc_info.text) list -> stringmethod str_man_of_return_opt : Odoc_info.text option -> stringmethod str_man_of_see : (Odoc_info.see_ref * Odoc_info.text) -> stringmethod str_man_of_sees : (Odoc_info.see_ref * Odoc_info.text) list -> stringmethod str_man_of_text : Odoc_info.text -> stringOdoc_gen.Man_functor_.texival mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval node_tbl : (Odoc_info.Name.t, unit) Hashtbl.tval minus : Odoc_info.text_elementval linebreak : Odoc_info.text_elementval bullet : Odoc_info.text_elementmethod escape : Odoc_info.Name.t -> Odoc_info.Name.tmethod fixedblock : Odoc_info.text_element list -> Odoc_info.text_elementmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_class : out_channel -> Odoc_info.Class.t_class -> unitmethod generate_for_class_type : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : out_channel -> Odoc_info.Module.t_module -> unitmethod generate_for_module_type : out_channel ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_inheritance_info : out_channel ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_texi_header : out_channel ->
+ string ->
+ Odoc_info.Module.t_module list ->
+ unitmethod generate_texi_trailer : out_channel -> unitmethod heading : int -> Odoc_info.text -> stringmethod index : Odoc_texi.indices -> Odoc_info.Name.t -> Odoc_info.text_elementmethod node : int -> Odoc_info.Name.t -> Odoc_info.text_elementmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod scan_for_index : Odoc_texi.subparts -> unitmethod scan_for_index_in_class : Odoc_info.Class.class_element -> unitmethod scan_for_index_in_mod : Odoc_info.Module.module_element -> unitmethod string_of_type_args : Odoc_info.Type.constructor_args ->
+ Types.type_expr option ->
+ stringmethod string_of_type_parameters : Odoc_info.Type.t_type -> stringmethod texi_of_Block : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Bold : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Center : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Code : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_CodePre : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Emphasize : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Enum : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Italic : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Left : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Link : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_List : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Newline : Odoc_info.Name.tmethod texi_of_Raw : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Ref : Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.Name.tmethod texi_of_Right : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Subscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Superscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Target : target:string ->
+ code:Odoc_info.Name.t ->
+ Odoc_info.Name.tmethod texi_of_Title : int -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Verbatim : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_attribute : Odoc_info.Value.t_attribute -> stringmethod texi_of_class : Odoc_info.Class.t_class -> stringmethod texi_of_class_element : Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ stringmethod texi_of_class_type : Odoc_info.Class.t_class_type -> stringmethod texi_of_custom_text : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_exception : Odoc_info.Exception.t_exception -> stringmethod texi_of_included_module : Odoc_info.Module.included_module -> stringmethod texi_of_info : Odoc_info.info option -> stringmethod texi_of_method : Odoc_info.Value.t_method -> stringmethod texi_of_module : Odoc_info.Module.t_module -> stringmethod texi_of_module_element : Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ stringmethod texi_of_module_type : Odoc_info.Module.t_module_type -> stringmethod texi_of_text : Odoc_info.text -> stringmethod texi_of_text_element : Odoc_info.text_element -> Odoc_info.Name.tmethod texi_of_type : Odoc_info.Type.t_type -> stringmethod texi_of_type_extension : Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ stringmethod texi_of_value : Odoc_info.Value.t_value -> stringmethod text_el_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_elementmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_desc : Odoc_info.text option -> Odoc_info.text_element listmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_params : Odoc_info.param list -> Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_sees_opt : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listTexi_functor._class texi : object ... endTexi_functor.texival mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval node_tbl : (Odoc_info.Name.t, unit) Hashtbl.tval minus : Odoc_info.text_elementval linebreak : Odoc_info.text_elementval bullet : Odoc_info.text_elementmethod escape : Odoc_info.Name.t -> Odoc_info.Name.tmethod fixedblock : Odoc_info.text_element list -> Odoc_info.text_elementmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_class : out_channel -> Odoc_info.Class.t_class -> unitmethod generate_for_class_type : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : out_channel -> Odoc_info.Module.t_module -> unitmethod generate_for_module_type : out_channel ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_inheritance_info : out_channel ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_texi_header : out_channel ->
+ string ->
+ Odoc_info.Module.t_module list ->
+ unitmethod generate_texi_trailer : out_channel -> unitmethod heading : int -> Odoc_info.text -> stringmethod index : Odoc_texi.indices -> Odoc_info.Name.t -> Odoc_info.text_elementmethod node : int -> Odoc_info.Name.t -> Odoc_info.text_elementmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod scan_for_index : Odoc_texi.subparts -> unitmethod scan_for_index_in_class : Odoc_info.Class.class_element -> unitmethod scan_for_index_in_mod : Odoc_info.Module.module_element -> unitmethod string_of_type_args : Odoc_info.Type.constructor_args ->
+ Types.type_expr option ->
+ stringmethod string_of_type_parameters : Odoc_info.Type.t_type -> stringmethod texi_of_Block : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Bold : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Center : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Code : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_CodePre : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Emphasize : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Enum : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Italic : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Left : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Link : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_List : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Newline : Odoc_info.Name.tmethod texi_of_Raw : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Ref : Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.Name.tmethod texi_of_Right : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Subscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Superscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Target : target:string ->
+ code:Odoc_info.Name.t ->
+ Odoc_info.Name.tmethod texi_of_Title : int -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Verbatim : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_attribute : Odoc_info.Value.t_attribute -> stringmethod texi_of_class : Odoc_info.Class.t_class -> stringmethod texi_of_class_element : Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ stringmethod texi_of_class_type : Odoc_info.Class.t_class_type -> stringmethod texi_of_custom_text : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_exception : Odoc_info.Exception.t_exception -> stringmethod texi_of_included_module : Odoc_info.Module.included_module -> stringmethod texi_of_info : Odoc_info.info option -> stringmethod texi_of_method : Odoc_info.Value.t_method -> stringmethod texi_of_module : Odoc_info.Module.t_module -> stringmethod texi_of_module_element : Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ stringmethod texi_of_module_type : Odoc_info.Module.t_module_type -> stringmethod texi_of_text : Odoc_info.text -> stringmethod texi_of_text_element : Odoc_info.text_element -> Odoc_info.Name.tmethod texi_of_type : Odoc_info.Type.t_type -> stringmethod texi_of_type_extension : Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ stringmethod texi_of_value : Odoc_info.Value.t_value -> stringmethod text_el_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_elementmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_desc : Odoc_info.text option -> Odoc_info.text_element listmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_params : Odoc_info.param list -> Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_sees_opt : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listOdoc_gen.Texi_functorOdoc_globalval include_dirs : string list refval merge_options : Odoc_types.merge_option list refval classic : bool refval dump : string option refval load : string list refval sort_modules : bool refval no_stop : bool refval no_custom_tags : bool refval remove_stars : bool refval keep_code : bool refval inverse_merge_ml_mli : bool refval filter_with_module_constraints : bool refval files : source_file list refval errors : int refval warn_error : bool refval show_missed_crossref : bool refval out_file : string refval verbose : bool refval intro_file : string option refval title : string option refval target_dir : string refval with_toc : bool refval with_index : bool refval with_header : bool refval with_trailer : bool refval initially_opened_module : string refval library_namespace : string refGenerator.htmlval mutable tag_functions : (string * (Odoc_info.text -> string)) listval mutable list_values : Odoc_info.Value.t_value listval mutable list_types : Odoc_info.Type.t_type listval mutable list_modules : Odoc_info.Module.t_module listval mutable list_module_types : Odoc_info.Module.t_module_type listval mutable list_methods : Odoc_info.Value.t_method listval mutable list_extensions : Odoc_info.Extension.t_extension_constructor listval mutable list_exceptions : Odoc_info.Exception.t_exception listval mutable list_classes : Odoc_info.Class.t_class listval mutable list_class_types : Odoc_info.Class.t_class_type listval mutable list_attributes : Odoc_info.Value.t_attribute listval mutable known_types_names : String.Set.tval mutable known_modules_names : String.Set.tval mutable known_classes_names : String.Set.tval mutable header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitmethod character_encoding : Buffer.t -> unitmethod create_fully_qualified_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_fully_qualified_module_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_title_label : (int * string option * Odoc_info.text) -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_attributes_index : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_class_types_index : Odoc_info.Module.t_module list -> unitmethod generate_classes_index : Odoc_info.Module.t_module list -> unitmethod generate_elements_index : 'a. ?strip_libname:bool ->
+ 'a list ->
+ ('a -> Odoc_info.Name.t) ->
+ ('a -> Odoc_info.info option) ->
+ ('a -> string) ->
+ string ->
+ string ->
+ unitmethod generate_exceptions_index : Odoc_info.Module.t_module list -> unitmethod generate_extensions_index : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_for_class_type : Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_for_module_type : Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_index : Odoc_info.Module.t_module list -> unitmethod generate_inheritance_info : Buffer.t ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_methods_index : Odoc_info.Module.t_module list -> unitmethod generate_module_types_index : Odoc_info.Module.t_module list -> unitmethod generate_modules_index : Odoc_info.Module.t_module list -> unitmethod generate_types_index : Odoc_info.Module.t_module list -> unitmethod generate_values_index : Odoc_info.Module.t_module list -> unitmethod html_of_Block : Buffer.t -> Odoc_info.text -> unitmethod html_of_Bold : Buffer.t -> Odoc_info.text -> unitmethod html_of_Center : Buffer.t -> Odoc_info.text -> unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Emphasize : Buffer.t -> Odoc_info.text -> unitmethod html_of_Enum : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Index_list : Buffer.t -> unitmethod html_of_Italic : Buffer.t -> Odoc_info.text -> unitmethod html_of_Latex : Buffer.t -> string -> unitmethod html_of_Left : Buffer.t -> Odoc_info.text -> unitmethod html_of_Link : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_List : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Module_list : Buffer.t -> Odoc_info.Name.t list -> unitmethod html_of_Newline : Buffer.t -> unitmethod html_of_Raw : Buffer.t -> string -> unitmethod html_of_Ref : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod html_of_Right : Buffer.t -> Odoc_info.text -> unitmethod html_of_Subscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Superscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Target : Buffer.t -> target:string -> code:string -> unitmethod html_of_Title : Buffer.t ->
+ int ->
+ string option ->
+ Odoc_info.text ->
+ unitmethod html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod html_of_author_list : Buffer.t -> string list -> unitmethod html_of_before : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_class : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_class_element : Buffer.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod html_of_class_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?cl:Odoc_info.Class.t_class ->
+ Odoc_info.Class.class_kind ->
+ unitmethod html_of_class_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_type : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod html_of_class_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?ct:Odoc_info.Class.t_class_type ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod html_of_class_type_param_expr_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr list ->
+ unitmethod html_of_code : Buffer.t -> ?with_pre:bool -> string -> unitmethod html_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod html_of_custom : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_dag : (Odoc_info.Name.t * Odoc_info.Class.cct option)
+ Odoc_dag2html.dag ->
+ stringmethod html_of_described_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod html_of_included_module : Buffer.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod html_of_info : ?cls:string ->
+ ?indent:bool ->
+ Buffer.t ->
+ Odoc_types.info option ->
+ unitmethod html_of_info_first_sentence : Buffer.t -> Odoc_info.info option -> unitmethod html_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod html_of_modtype : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod html_of_module : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module ->
+ unitmethod html_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_module_element : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod html_of_module_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ Odoc_info.Module.module_kind ->
+ unitmethod html_of_module_parameter : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod html_of_module_parameter_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_type : Buffer.t ->
+ ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod html_of_module_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ ?mt:Odoc_info.Module.t_module_type ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod html_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod html_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_raised_exceptions : Buffer.t ->
+ (string * Odoc_info.text) list ->
+ unitmethod html_of_record : father:Odoc_info.Name.t ->
+ close_env:string ->
+ (Odoc_info.Type.record_field -> string) ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod html_of_return_opt : Buffer.t -> Odoc_info.text option -> unitmethod html_of_see : Buffer.t -> (Odoc_info.see_ref * Odoc_info.text) -> unitmethod html_of_sees : Buffer.t ->
+ (Odoc_info.see_ref * Odoc_info.text) list ->
+ unitmethod html_of_since_opt : Buffer.t -> string option -> unitmethod html_of_text : ?with_p:bool -> Buffer.t -> Odoc_info.text -> unitmethod html_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod html_of_text_with_p : Buffer.t -> Odoc_info.text -> unitmethod html_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod html_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod html_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod html_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod html_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod html_of_version_opt : Buffer.t -> string option -> unitmethod html_sections_links : Buffer.t -> Odoc_info.text list -> unitmethod inner_title : Odoc_info.Name.t -> stringmethod label_of_text : Odoc_info.text -> stringmethod list_attributes : Odoc_info.Value.t_attribute listmethod list_class_types : Odoc_info.Class.t_class_type listmethod list_classes : Odoc_info.Class.t_class listmethod list_exceptions : Odoc_info.Exception.t_exception listmethod list_extensions : Odoc_info.Extension.t_extension_constructor listmethod list_methods : Odoc_info.Value.t_method listmethod list_module_types : Odoc_info.Module.t_module_type listmethod list_modules : Odoc_info.Module.t_module listmethod list_types : Odoc_info.Type.t_type listmethod list_values : Odoc_info.Value.t_value listmethod meta : Buffer.t -> unitmethod output_class_type : Odoc_info.Name.t ->
+ string ->
+ Types.class_type ->
+ unitmethod output_module_type : Odoc_info.Name.t ->
+ string ->
+ Types.module_type ->
+ unitmethod prepare_header : Odoc_info.Module.t_module list -> unitmethod print_header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitOdoc_html.Generatorclass html : object ... endOdoc_html.Namingval complete_target : string -> Odoc_info.Name.t -> stringval module_target : Odoc_info.Module.t_module -> stringval module_type_target : Odoc_info.Module.t_module_type -> stringval type_target : Odoc_info.Type.t_type -> stringval const_target :
+ Odoc_info.Type.t_type ->
+ Odoc_info.Type.variant_constructor ->
+ stringval recfield_target :
+ Odoc_info.Type.t_type ->
+ Odoc_info.Type.record_field ->
+ stringval inline_recfield_target :
+ string ->
+ string ->
+ Odoc_info.Type.record_field ->
+ stringval objfield_target :
+ Odoc_info.Type.t_type ->
+ Odoc_info.Type.object_field ->
+ stringval complete_type_target : Odoc_info.Type.t_type -> stringval complete_recfield_target : Odoc_info.Name.t -> stringval complete_const_target : Odoc_info.Name.t -> stringval extension_target : Odoc_info.Extension.t_extension_constructor -> stringval complete_extension_target :
+ Odoc_info.Extension.t_extension_constructor ->
+ stringval exception_target : Odoc_info.Exception.t_exception -> stringval complete_exception_target : Odoc_info.Exception.t_exception -> stringval value_target : Odoc_info.Value.t_value -> stringval complete_value_target : Odoc_info.Value.t_value -> stringval file_code_value_complete_target : Odoc_info.Value.t_value -> stringval attribute_target : Odoc_info.Value.t_attribute -> stringval complete_attribute_target : Odoc_info.Value.t_attribute -> stringval file_code_attribute_complete_target : Odoc_info.Value.t_attribute -> stringval method_target : Odoc_info.Value.t_method -> stringval complete_method_target : Odoc_info.Value.t_method -> stringval file_code_method_complete_target : Odoc_info.Value.t_method -> stringval complete_label_target : Odoc_info.Name.t -> stringOdoc_html.infoval mutable tag_functions : (string * (Odoc_info.text -> string)) listmethod html_of_author_list : Buffer.t -> string list -> unitmethod html_of_before : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_custom : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_info : ?cls:string ->
+ ?indent:bool ->
+ Buffer.t ->
+ Odoc_types.info option ->
+ unitmethod html_of_info_first_sentence : Buffer.t -> Odoc_types.info option -> unitmethod html_of_raised_exceptions : Buffer.t ->
+ (string * Odoc_info.text) list ->
+ unitmethod html_of_return_opt : Buffer.t -> Odoc_info.text option -> unitmethod html_of_see : Buffer.t -> (Odoc_info.see_ref * Odoc_info.text) -> unitmethod html_of_sees : Buffer.t ->
+ (Odoc_info.see_ref * Odoc_info.text) list ->
+ unitmethod html_of_since_opt : Buffer.t -> string option -> unitmethod html_of_text : ?with_p:bool -> Buffer.t -> Odoc_info.text -> unitmethod html_of_version_opt : Buffer.t -> string option -> unitOdoc_html.ocaml_codemethod html_of_code : Buffer.t -> ?with_pre:bool -> string -> unitOdoc_html.textmethod create_title_label : (int * string option * Odoc_info.text) -> stringmethod html_of_Block : Buffer.t -> Odoc_info.text -> unitmethod html_of_Bold : Buffer.t -> Odoc_info.text -> unitmethod html_of_Center : Buffer.t -> Odoc_info.text -> unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Emphasize : Buffer.t -> Odoc_info.text -> unitmethod html_of_Enum : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Index_list : Buffer.t -> unitmethod html_of_Italic : Buffer.t -> Odoc_info.text -> unitmethod html_of_Latex : Buffer.t -> string -> unitmethod html_of_Left : Buffer.t -> Odoc_info.text -> unitmethod html_of_Link : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_List : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Module_list : Buffer.t -> Odoc_info.Name.t list -> unitmethod html_of_Newline : Buffer.t -> unitmethod html_of_Raw : Buffer.t -> string -> unitmethod html_of_Ref : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod html_of_Right : Buffer.t -> Odoc_info.text -> unitmethod html_of_Subscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Superscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Target : Buffer.t -> target:string -> code:string -> unitmethod html_of_Title : Buffer.t ->
+ int ->
+ string option ->
+ Odoc_info.text ->
+ unitmethod html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_code : Buffer.t -> ?with_pre:bool -> string -> unitmethod html_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_info_first_sentence : Buffer.t -> Odoc_info.info option -> unitmethod html_of_text : ?with_p:bool -> Buffer.t -> Odoc_info.text -> unitmethod html_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod html_of_text_with_p : Buffer.t -> Odoc_info.text -> unitmethod label_of_text : Odoc_info.text -> stringmethod list_attributes : Odoc_info.Value.t_attribute listmethod list_class_types : Odoc_info.Class.t_class_type listmethod list_classes : Odoc_info.Class.t_class listmethod list_exceptions : Odoc_info.Exception.t_exception listmethod list_extensions : Odoc_info.Extension.t_extension_constructor listmethod list_methods : Odoc_info.Value.t_method listmethod list_module_types : Odoc_info.Module.t_module_type listmethod list_modules : Odoc_info.Module.t_module listmethod list_types : Odoc_info.Type.t_type listmethod list_values : Odoc_info.Value.t_value listOdoc_htmlmodule String = Misc.Stdlib.Stringval with_parameter_list : bool refval css_style : string option refval index_only : bool refval colorize_code : bool refval html_short_functors : bool refval charset : string refmodule Naming : sig ... endclass ocaml_code : object ... endval new_buf : unit -> Stdlib.Buffer.tval bp : Stdlib.Buffer.t -> ('a, Stdlib.Buffer.t, unit) format -> 'aval bs : Stdlib.Buffer.t -> string -> unitclass virtual text : object ... endclass virtual info : object ... endval print_concat : Stdlib.Buffer.t -> string -> ('a -> unit) -> 'a list -> unitmodule Generator : sig ... endmodule type Html_generator = sig ... endHtml_generator.htmlval mutable tag_functions : (string * (Odoc_info.text -> string)) listval mutable list_values : Odoc_info.Value.t_value listval mutable list_types : Odoc_info.Type.t_type listval mutable list_modules : Odoc_info.Module.t_module listval mutable list_module_types : Odoc_info.Module.t_module_type listval mutable list_methods : Odoc_info.Value.t_method listval mutable list_extensions : Odoc_info.Extension.t_extension_constructor listval mutable list_exceptions : Odoc_info.Exception.t_exception listval mutable list_classes : Odoc_info.Class.t_class listval mutable list_class_types : Odoc_info.Class.t_class_type listval mutable list_attributes : Odoc_info.Value.t_attribute listval mutable known_types_names : String.Set.tval mutable known_modules_names : String.Set.tval mutable known_classes_names : String.Set.tval mutable header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitmethod character_encoding : Buffer.t -> unitmethod create_fully_qualified_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_fully_qualified_module_idents_links : Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ stringmethod create_title_label : (int * string option * Odoc_info.text) -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_attributes_index : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Buffer.t ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_class_types_index : Odoc_info.Module.t_module list -> unitmethod generate_classes_index : Odoc_info.Module.t_module list -> unitmethod generate_elements_index : 'a. ?strip_libname:bool ->
+ 'a list ->
+ ('a -> Odoc_info.Name.t) ->
+ ('a -> Odoc_info.info option) ->
+ ('a -> string) ->
+ string ->
+ string ->
+ unitmethod generate_exceptions_index : Odoc_info.Module.t_module list -> unitmethod generate_extensions_index : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class option ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_for_class_type : Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type option ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module option ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_for_module_type : Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type option ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_index : Odoc_info.Module.t_module list -> unitmethod generate_inheritance_info : Buffer.t ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_methods_index : Odoc_info.Module.t_module list -> unitmethod generate_module_types_index : Odoc_info.Module.t_module list -> unitmethod generate_modules_index : Odoc_info.Module.t_module list -> unitmethod generate_types_index : Odoc_info.Module.t_module list -> unitmethod generate_values_index : Odoc_info.Module.t_module list -> unitmethod html_of_Block : Buffer.t -> Odoc_info.text -> unitmethod html_of_Bold : Buffer.t -> Odoc_info.text -> unitmethod html_of_Center : Buffer.t -> Odoc_info.text -> unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Emphasize : Buffer.t -> Odoc_info.text -> unitmethod html_of_Enum : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Index_list : Buffer.t -> unitmethod html_of_Italic : Buffer.t -> Odoc_info.text -> unitmethod html_of_Latex : Buffer.t -> string -> unitmethod html_of_Left : Buffer.t -> Odoc_info.text -> unitmethod html_of_Link : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_List : Buffer.t -> Odoc_info.text list -> unitmethod html_of_Module_list : Buffer.t -> Odoc_info.Name.t list -> unitmethod html_of_Newline : Buffer.t -> unitmethod html_of_Raw : Buffer.t -> string -> unitmethod html_of_Ref : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod html_of_Right : Buffer.t -> Odoc_info.text -> unitmethod html_of_Subscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Superscript : Buffer.t -> Odoc_info.text -> unitmethod html_of_Target : Buffer.t -> target:string -> code:string -> unitmethod html_of_Title : Buffer.t ->
+ int ->
+ string option ->
+ Odoc_info.text ->
+ unitmethod html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod html_of_author_list : Buffer.t -> string list -> unitmethod html_of_before : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_class : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_class_element : Buffer.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod html_of_class_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?cl:Odoc_info.Class.t_class ->
+ Odoc_info.Class.class_kind ->
+ unitmethod html_of_class_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod html_of_class_type : Buffer.t ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod html_of_class_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?ct:Odoc_info.Class.t_class_type ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod html_of_class_type_param_expr_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr list ->
+ unitmethod html_of_code : Buffer.t -> ?with_pre:bool -> string -> unitmethod html_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod html_of_custom : Buffer.t -> (string * Odoc_info.text) list -> unitmethod html_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod html_of_dag : (Odoc_info.Name.t * Odoc_info.Class.cct option)
+ Odoc_dag2html.dag ->
+ stringmethod html_of_described_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod html_of_included_module : Buffer.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod html_of_info : ?cls:string ->
+ ?indent:bool ->
+ Buffer.t ->
+ Odoc_types.info option ->
+ unitmethod html_of_info_first_sentence : Buffer.t -> Odoc_info.info option -> unitmethod html_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod html_of_modtype : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod html_of_module : Buffer.t ->
+ ?info:bool ->
+ ?complete:bool ->
+ ?with_link:bool ->
+ Odoc_info.Module.t_module ->
+ unitmethod html_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod html_of_module_element : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod html_of_module_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ Odoc_info.Module.module_kind ->
+ unitmethod html_of_module_parameter : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod html_of_module_parameter_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod html_of_module_type : Buffer.t ->
+ ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod html_of_module_type_kind : Buffer.t ->
+ Odoc_info.Name.t ->
+ ?modu:Odoc_info.Module.t_module ->
+ ?mt:Odoc_info.Module.t_module_type ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod html_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod html_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_parameter.parameter list ->
+ unitmethod html_of_raised_exceptions : Buffer.t ->
+ (string * Odoc_info.text) list ->
+ unitmethod html_of_record : father:Odoc_info.Name.t ->
+ close_env:string ->
+ (Odoc_info.Type.record_field -> string) ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod html_of_return_opt : Buffer.t -> Odoc_info.text option -> unitmethod html_of_see : Buffer.t -> (Odoc_info.see_ref * Odoc_info.text) -> unitmethod html_of_sees : Buffer.t ->
+ (Odoc_info.see_ref * Odoc_info.text) list ->
+ unitmethod html_of_since_opt : Buffer.t -> string option -> unitmethod html_of_text : ?with_p:bool -> Buffer.t -> Odoc_info.text -> unitmethod html_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod html_of_text_with_p : Buffer.t -> Odoc_info.text -> unitmethod html_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod html_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod html_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod html_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod html_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod html_of_version_opt : Buffer.t -> string option -> unitmethod html_sections_links : Buffer.t -> Odoc_info.text list -> unitmethod inner_title : Odoc_info.Name.t -> stringmethod label_of_text : Odoc_info.text -> stringmethod list_attributes : Odoc_info.Value.t_attribute listmethod list_class_types : Odoc_info.Class.t_class_type listmethod list_classes : Odoc_info.Class.t_class listmethod list_exceptions : Odoc_info.Exception.t_exception listmethod list_extensions : Odoc_info.Extension.t_extension_constructor listmethod list_methods : Odoc_info.Value.t_method listmethod list_module_types : Odoc_info.Module.t_module_type listmethod list_modules : Odoc_info.Module.t_module listmethod list_types : Odoc_info.Type.t_type listmethod list_values : Odoc_info.Value.t_value listmethod meta : Buffer.t -> unitmethod output_class_type : Odoc_info.Name.t ->
+ string ->
+ Types.class_type ->
+ unitmethod output_module_type : Odoc_info.Name.t ->
+ string ->
+ Types.module_type ->
+ unitmethod prepare_header : Odoc_info.Module.t_module list -> unitmethod print_header : Buffer.t ->
+ ?nav:
+ (Odoc_info.Name.t option * Odoc_info.Name.t option * Odoc_info.Name.t)
+ option ->
+ ?comments:Odoc_info.text list ->
+ string ->
+ unitOdoc_html.Html_generatorclass html : object ... endOdoc_info.ClassRepresentation and manipulation of classes and class types.
type class_element = Odoc_class.class_element = | Class_attribute of Value.t_attribute| Class_method of Value.t_method| Class_comment of textTo keep the order of elements in a class.
type cct = Odoc_class.cct = | Cl of t_class| Cltype of t_class_type * Types.type_expr listClass type and type parameters.
*)Used when we can reference a t_class or a t_class_type.
and inherited_class = Odoc_class.inherited_class = {ic_name : Name.t;Complete name of the inherited class.
*)mutable ic_class : cct option;The associated t_class or t_class_type.
*)ic_text : text option;The inheritance description, if any.
*)}and class_apply = Odoc_class.class_apply = {capp_name : Name.t;The complete name of the applied class.
*)mutable capp_class : t_class option;The associated t_class if we found it.
*)capp_params : Types.type_expr list;The type of expressions the class is applied to.
*)capp_params_code : string list;The code of these expressions.
*)}and class_constr = Odoc_class.class_constr = {cco_name : Name.t;The complete name of the applied class.
*)mutable cco_class : cct option;The associated class or class type if we found it.
*)cco_type_parameters : Types.type_expr list;The type parameters of the class, if needed.
*)}and class_kind = Odoc_class.class_kind = | Class_structure of inherited_class list * class_element listAn explicit class structure, used in implementation and interface.
*)| Class_apply of class_applyApplication/alias of a class, used in implementation only.
*)| Class_constr of class_constrA class used to give the type of the defined class, instead of a structure, used in interface only. For example, it will be used with the name M1.M2....bar when the class foo is defined like this : class foo : int -> bar
| Class_constraint of class_kind * class_type_kindA class definition with a constraint.
*)and t_class = Odoc_class.t_class = {cl_name : Name.t;Complete name of the class.
*)mutable cl_info : info option;Information found in the optional associated comment.
*)cl_type : Types.class_type;Type of the class.
*)cl_type_parameters : Types.type_expr list;Type parameters.
*)cl_virtual : bool;true when the class is virtual.
mutable cl_kind : class_kind;The way the class is defined.
*)mutable cl_parameters : Parameter.parameter list;The parameters of the class.
*)mutable cl_loc : location;}Representation of a class.
and class_type_alias = Odoc_class.class_type_alias = {cta_name : Name.t;Complete name of the target class type.
*)mutable cta_class : cct option;The target t_class or t_class_type, if we found it.
*)cta_type_parameters : Types.type_expr list;The type parameters. FIXME : use strings?
*)}and class_type_kind = Odoc_class.class_type_kind = | Class_signature of inherited_class list * class_element list| Class_type of class_type_aliasA class type eventually applied to type args.
*)and t_class_type = Odoc_class.t_class_type = {clt_name : Name.t;Complete name of the type.
*)mutable clt_info : info option;Information found in the optional associated comment.
*)clt_type : Types.class_type;clt_type_parameters : Types.type_expr list;Type parameters.
*)clt_virtual : bool;true if the class type is virtual
mutable clt_kind : class_type_kind;The way the class type is defined.
*)mutable clt_loc : location;}Representation of a class type.
val class_elements : ?trans:bool -> t_class -> class_element listAccess to the elements of a class.
val class_attributes : ?trans:bool -> t_class -> Value.t_attribute listAccess to the list of class attributes.
Access to the description associated to the given class parameter name.
val class_methods : ?trans:bool -> t_class -> Value.t_method listAccess to the methods of a class.
val class_type_elements : ?trans:bool -> t_class_type -> class_element listAccess to the elements of a class type.
val class_type_attributes :
+ ?trans:bool ->
+ t_class_type ->
+ Value.t_attribute listAccess to the list of class type attributes.
val class_type_parameter_text_by_name : t_class_type -> string -> text optionAccess to the description associated to the given class type parameter name.
val class_type_methods : ?trans:bool -> t_class_type -> Value.t_method listAccess to the methods of a class type.
val class_type_comments : ?trans:bool -> t_class_type -> text listAccess to the comments of a class type.
Odoc_info.DepComputation of dependencies.
val kernel_deps_of_modules : Module.t_module list -> unitModify the module dependencies of the given list of modules, to get the minimum transitivity kernel.
val deps_of_types :
+ ?kernel:bool ->
+ Type.t_type list ->
+ (Type.t_type * Name.t list) listReturn the list of dependencies between the given types, in the form of a list (type name, names of types it depends on).
Odoc_info.ExceptionRepresentation and manipulation of exceptions.
type exception_alias = Odoc_exception.exception_alias = {ea_name : Name.t;The complete name of the target exception.
*)mutable ea_ex : t_exception option;The target exception, if we found it.
*)}Used when the exception is a rebind of another exception, when we have exception Ex = Target_ex.
and t_exception = Odoc_exception.t_exception = {ex_name : Name.t;mutable ex_info : info option;Information found in the optional associated comment.
*)ex_args : Odoc_type.constructor_args;ex_ret : Types.type_expr option;The optional return type of the exception.
*)ex_alias : exception_alias option;None when the exception is not a rebind.
mutable ex_loc : location;mutable ex_code : string option;}Odoc_info.ExtensionRepresentation and manipulation of extensions.
type extension_alias = Odoc_extension.extension_alias = {xa_name : Name.t;The complete name of the target extension.
*)mutable xa_xt : t_extension_constructor option;The target extension, if we found it.
*)}Used when the extension is a rebind of another extension, when we have extension Xt = Target_xt.
and t_extension_constructor = Odoc_extension.t_extension_constructor = {xt_name : Name.t;xt_args : Odoc_type.constructor_args;xt_ret : Types.type_expr option;the optional return type of the extension
*)xt_type_extension : t_type_extension;the type extension containing this constructor
*)xt_alias : extension_alias option;None when the extension is not a rebind.
mutable xt_loc : Odoc_types.location;mutable xt_text : Odoc_types.info option;optional user description
*)}and t_type_extension = Odoc_extension.t_type_extension = {mutable te_info : info option;Information found in the optional associated comment.
*)te_type_name : Name.t;The type of the extension
*)te_type_parameters : Types.type_expr list;te_private : private_flag;mutable te_constructors : t_extension_constructor list;mutable te_loc : location;mutable te_code : string option;}val extension_constructors : t_type_extension -> t_extension_constructor listAccess to the extensions in a group.
Odoc_info.Globalval errors : int refval warn_error : bool refval out_file : string refThe file used by the generators outputting only one file.
val verbose : bool refVerbose mode or not.
val target_dir : string refThe directory where files have to be generated.
val title : string option refThe optional title to use in the generated documentation.
val intro_file : string option refThe optional file whose content can be used as intro text.
val with_toc : bool refThe flag which indicates if we must generate a table of contents.
val with_index : bool refThe flag which indicates if we must generate an index.
val with_header : bool refThe flag which indicates if we must generate a header.
val with_trailer : bool refThe flag which indicates if we must generate a trailer.
Odoc_info.ModuleRepresentation and manipulation of modules and module types.
type module_element = Odoc_module.module_element = | Element_module of t_module| Element_module_type of t_module_type| Element_included_module of included_module| Element_class of Class.t_class| Element_class_type of Class.t_class_type| Element_value of Value.t_value| Element_type_extension of Extension.t_type_extension| Element_exception of Exception.t_exception| Element_type of Type.t_type| Element_module_comment of textTo keep the order of elements in a module.
Used where we can reference t_module or t_module_type.
and included_module = Odoc_module.included_module = {im_name : Name.t;Complete name of the included module.
*)mutable im_module : mmt option;The included module or module type, if we found it.
*)mutable im_info : Odoc_types.info option;comment associated with the include directive
*)}and module_alias = Odoc_module.module_alias = {ma_name : Name.t;Complete name of the target module.
*)mutable ma_module : mmt option;The real module or module type if we could associate it.
*)}and module_parameter = Odoc_module.module_parameter = {mp_name : string;the name
*)mp_type : Types.module_type option;the type
*)mp_type_code : string;the original code
*)mp_kind : module_type_kind;the way the parameter was built
*)}and module_kind = Odoc_module.module_kind = | Module_struct of module_element listA complete module structure.
*)| Module_alias of module_aliasComplete name and corresponding module if we found it
*)| Module_functor of module_parameter * module_kindA functor, with its parameter and the rest of its definition
*)| Module_apply of module_kind * module_kindA module defined by application of a functor.
*)| Module_with of module_type_kind * stringA module whose type is a with ... constraint. Should appear in interface files only.
*)| Module_constraint of module_kind * module_type_kindA module constraint by a module type.
*)| Module_typeof of stringby now only the code of the module expression
*)| Module_unpack of string * module_type_aliascode of the expression and module type alias
*)Different kinds of a module.
and t_module = Odoc_module.t_module = {m_name : Name.t;Complete name of the module.
*)mutable m_type : Types.module_type;The type of the module.
*)mutable m_info : info option;Information found in the optional associated comment.
*)m_is_interface : bool;true for modules read from interface files
m_file : string;The file the module is defined in.
*)mutable m_kind : module_kind;The way the module is defined.
*)mutable m_loc : location;mutable m_top_deps : Name.t list;The toplevels module names this module depends on.
*)mutable m_code : string option;The whole code of the module
*)mutable m_code_intf : string option;The whole code of the interface of the module
*)m_text_only : bool;true if the module comes from a text file
}Representation of a module.
and module_type_alias = Odoc_module.module_type_alias = {mta_name : Name.t;Complete name of the target module type.
*)mutable mta_module : t_module_type option;The real module type if we could associate it.
*)}and module_type_kind = Odoc_module.module_type_kind = | Module_type_struct of module_element listA complete module signature.
*)| Module_type_functor of module_parameter * module_type_kindA functor, with its parameter and the rest of its definition
*)| Module_type_alias of module_type_aliasComplete alias name and corresponding module type if we found it.
*)| Module_type_with of module_type_kind * stringThe module type kind and the code of the with constraint.
*)| Module_type_typeof of stringby now only the code of the module expression
*)Different kinds of module type.
and t_module_type = Odoc_module.t_module_type = {mt_name : Name.t;Complete name of the module type.
*)mutable mt_info : info option;Information found in the optional associated comment.
*)mutable mt_type : Types.module_type option;None means that the module type is abstract.
mt_is_interface : bool;true for modules read from interface files.
mt_file : string;The file the module type is defined in.
*)mutable mt_kind : module_type_kind option;The way the module is defined. None means that module type is abstract. It is always None when the module type was extracted from the implementation file. That means module types are only analysed in interface files.
mutable mt_loc : location;}Representation of a module type.
val module_elements : ?trans:bool -> t_module -> module_element listAccess to the elements of a module.
val module_module_types : ?trans:bool -> t_module -> t_module_type listAccess to the module types of a module.
val module_included_modules : ?trans:bool -> t_module -> included_module listAccess to the included modules of a module.
val module_type_extensions :
+ ?trans:bool ->
+ t_module ->
+ Extension.t_type_extension listAccess to the type extensions of a module.
val module_exceptions : ?trans:bool -> t_module -> Exception.t_exception listAccess to the exceptions of a module.
val module_types : ?trans:bool -> t_module -> Type.t_type listAccess to the types of a module.
val module_values : ?trans:bool -> t_module -> Value.t_value listAccess to the values of a module.
val module_functions : ?trans:bool -> t_module -> Value.t_value listAccess to functional values of a module.
val module_simple_values : ?trans:bool -> t_module -> Value.t_value listAccess to non-functional values of a module.
val module_classes : ?trans:bool -> t_module -> Class.t_class listAccess to the classes of a module.
val module_class_types : ?trans:bool -> t_module -> Class.t_class_type listAccess to the class types of a module.
val module_all_classes : ?trans:bool -> t_module -> Class.t_class listThe list of classes defined in this module and all its submodules and functors.
val module_is_functor : t_module -> booltrue if the module is functor.
val module_parameters :
+ ?trans:bool ->
+ t_module ->
+ (module_parameter * text option) listThe list of couples (module parameter, optional description).
val module_type_elements : ?trans:bool -> t_module_type -> module_element listAccess to the elements of a module type.
val module_type_modules : ?trans:bool -> t_module_type -> t_module listAccess to the submodules of a module type.
val module_type_module_types :
+ ?trans:bool ->
+ t_module_type ->
+ t_module_type listAccess to the module types of a module type.
val module_type_included_modules :
+ ?trans:bool ->
+ t_module_type ->
+ included_module listAccess to the included modules of a module type.
val module_type_exceptions :
+ ?trans:bool ->
+ t_module_type ->
+ Exception.t_exception listAccess to the exceptions of a module type.
val module_type_types : ?trans:bool -> t_module_type -> Type.t_type listAccess to the types of a module type.
val module_type_values : ?trans:bool -> t_module_type -> Value.t_value listAccess to the values of a module type.
val module_type_functions : ?trans:bool -> t_module_type -> Value.t_value listAccess to functional values of a module type.
val module_type_simple_values :
+ ?trans:bool ->
+ t_module_type ->
+ Value.t_value listAccess to non-functional values of a module type.
val module_type_classes : ?trans:bool -> t_module_type -> Class.t_class listAccess to the classes of a module type.
val module_type_class_types :
+ ?trans:bool ->
+ t_module_type ->
+ Class.t_class_type listAccess to the class types of a module type.
val module_type_all_classes :
+ ?trans:bool ->
+ t_module_type ->
+ Class.t_class listThe list of classes defined in this module type and all its submodules and functors.
val module_type_is_functor : t_module_type -> booltrue if the module type is functor.
val module_type_parameters :
+ ?trans:bool ->
+ t_module_type ->
+ (module_parameter * text option) listThe list of couples (module parameter, optional description).
val module_type_comments : ?trans:bool -> t_module_type -> text listThe list of module comments.
Odoc_info.NameRepresentation of element names.
val depth : t -> intReturn the depth of the name, i.e. the number of levels to the root. Example : depth "Toto.Tutu.name" = 3.
Take two names n1 and n2 = n3.n4 and return n4 if n3=n1 and n1<>"" or else n2.
Odoc_info.ParameterRepresentation and manipulation of method / function / class / module parameters.
type simple_name = Odoc_parameter.simple_name = {sn_name : string;sn_type : Types.type_expr;mutable sn_text : text option;}Representation of a simple parameter name
type param_info = Odoc_parameter.param_info = | Simple_name of simple_name| Tuple of param_info list * Types.type_exprRepresentation of parameter names. We need it to represent parameter names in tuples. The value Tuple ([], t) stands for an anonymous parameter.
type parameter = param_infoA parameter is just a param_info.
val complete_name : parameter -> stringAccess to the name as a string. For tuples, parentheses and commas are added.
val typ : parameter -> Types.type_exprAccess to the complete type.
val names : parameter -> string listAccess to the list of names ; only one for a simple parameter, or a list for a tuple.
val type_by_name : parameter -> string -> Types.type_exprAccess to the type of a specific name.
Scan.scannermethod scan_value : Value.t_value -> unitmethod scan_type_pre : Type.t_type -> boolmethod scan_type_const : Type.t_type -> Type.variant_constructor -> unitmethod scan_type_recfield : Type.t_type -> Type.record_field -> unitmethod scan_type : Type.t_type -> unitmethod scan_extension_constructor : Extension.t_extension_constructor -> unitmethod scan_exception : Exception.t_exception -> unitmethod scan_attribute : Value.t_attribute -> unitmethod scan_method : Value.t_method -> unitmethod scan_included_module : Module.included_module -> unitScan of a type extension
method scan_type_extension_pre : Extension.t_type_extension -> boolOverride this method to perform controls on the extension's type, private and info. This method is called before scanning the extension's constructors.
method scan_type_extension_constructors : Extension.t_type_extension -> unitThis method scans the constructors of the given type extension.
method scan_type_extension : Extension.t_type_extension -> unitScan of a type extension. Should not be overridden. It calls scan_type_extension_pre and if scan_type_extension_pre returns true, then it calls scan_type_extension_constructors.
Scan of a class.
method scan_class_comment : text -> unitScan of a comment inside a class.
method scan_class_pre : Class.t_class -> boolOverride this method to perform controls on the class comment and params. This method is called before scanning the class elements.
method scan_class_elements : Class.t_class -> unitThis method scans the elements of the given class.
method scan_class : Class.t_class -> unitScan of a class. Should not be overridden. It calls scan_class_pre and if scan_class_pre returns true, then it calls scan_class_elements.
Scan of a class type.
method scan_class_type_comment : text -> unitScan of a comment inside a class type.
method scan_class_type_pre : Class.t_class_type -> boolOverride this method to perform controls on the class type comment and form. This method is called before scanning the class type elements.
method scan_class_type_elements : Class.t_class_type -> unitThis method scans the elements of the given class type.
method scan_class_type : Class.t_class_type -> unitScan of a class type. Should not be overridden. It calls scan_class_type_pre and if scan_class_type_pre returns true, then it calls scan_class_type_elements.
Scan of modules.
method scan_module_comment : text -> unitScan of a comment inside a module.
method scan_module_pre : Module.t_module -> boolOverride this method to perform controls on the module comment and form. This method is called before scanning the module elements.
method scan_module_elements : Module.t_module -> unitThis method scans the elements of the given module.
method scan_module : Module.t_module -> unitScan of a module. Should not be overridden. It calls scan_module_pre and if scan_module_pre returns true, then it calls scan_module_elements.
Scan of module types.
method scan_module_type_comment : text -> unitScan of a comment inside a module type.
method scan_module_type_pre : Module.t_module_type -> boolOverride this method to perform controls on the module type comment and form. This method is called before scanning the module type elements.
method scan_module_type_elements : Module.t_module_type -> unitThis method scans the elements of the given module type.
method scan_module_type : Module.t_module_type -> unitScan of a module type. Should not be overridden. It calls scan_module_type_pre and if scan_module_type_pre returns true, then it calls scan_module_type_elements.
Main scanning method.
method scan_module_list : Module.t_module list -> unitScan a list of modules.
Odoc_info.ScanScanning of collected information
class scanner : object ... endOdoc_info.SearchResearch in elements
type result_element = Odoc_search.result_element = | Res_module of Module.t_module| Res_module_type of Module.t_module_type| Res_class of Class.t_class| Res_class_type of Class.t_class_type| Res_value of Value.t_value| Res_type of Type.t_type| Res_extension of Extension.t_extension_constructor| Res_exception of Exception.t_exception| Res_attribute of Value.t_attribute| Res_method of Value.t_method| Res_section of string * text| Res_recfield of Type.t_type * Type.record_field| Res_const of Type.t_type * Type.variant_constructortype search_result = result_element listThe type representing a research result.
val search_by_name : Module.t_module list -> Str.regexp -> search_resultResearch of the elements whose name matches the given regular expression.
val values : Module.t_module list -> Value.t_value listA function to search all the values in a list of modules.
val extensions : Module.t_module list -> Extension.t_extension_constructor listA function to search all the extensions in a list of modules.
val exceptions : Module.t_module list -> Exception.t_exception listA function to search all the exceptions in a list of modules.
val types : Module.t_module list -> Type.t_type listA function to search all the types in a list of modules.
val attributes : Module.t_module list -> Value.t_attribute listA function to search all the class attributes in a list of modules.
val methods : Module.t_module list -> Value.t_method listA function to search all the class methods in a list of modules.
val classes : Module.t_module list -> Class.t_class listA function to search all the classes in a list of modules.
val class_types : Module.t_module list -> Class.t_class_type listA function to search all the class types in a list of modules.
val modules : Module.t_module list -> Module.t_module listA function to search all the modules in a list of modules.
val module_types : Module.t_module list -> Module.t_module_type listA function to search all the module types in a list of modules.
Odoc_info.TypeRepresentation and manipulation of types.
type record_field = Odoc_type.record_field = {rf_name : string;Name of the field.
*)rf_mutable : bool;true if mutable.
rf_type : Types.type_expr;Type of the field.
*)mutable rf_text : info option;Optional description in the associated comment.
*)}Description of a record type field.
type constructor_args = Odoc_type.constructor_args = | Cstr_record of record_field list| Cstr_tuple of Types.type_expr listDescription of a variant type constructor.
type variant_constructor = Odoc_type.variant_constructor = {vc_name : string;Name of the constructor.
*)vc_args : constructor_args;vc_ret : Types.type_expr option;mutable vc_text : info option;Optional description in the associated comment.
*)}type type_kind = Odoc_type.type_kind = | Type_abstractType is abstract, for example type t.
| Type_variant of variant_constructor listconstructors
*)| Type_record of record_field listfields
*)| Type_openType is open
*)The various kinds of a type.
type object_field = Odoc_type.object_field = {of_name : string;of_type : Types.type_expr;mutable of_text : Odoc_types.info option;optional user description
*)}type type_manifest = Odoc_type.type_manifest = | Other of Types.type_exprType manifest directly taken from Typedtree.
*)| Object_type of object_field listtype t_type = Odoc_type.t_type = {ty_name : Name.t;Complete name of the type.
*)mutable ty_info : info option;Information found in the optional associated comment.
*)ty_parameters : (Types.type_expr * bool * bool) list;type parameters: (type, covariant, contravariant)
*)ty_kind : type_kind;Type kind.
*)ty_private : private_flag;Private or public type.
*)ty_manifest : type_manifest option;mutable ty_loc : location;mutable ty_code : string option;}Representation of a type.
Odoc_info.ValueRepresentation and manipulation of values, class attributes and class methods.
type t_value = Odoc_value.t_value = {val_name : Name.t;Complete name of the value.
*)mutable val_info : info option;Information found in the optional associated comment.
*)val_type : Types.type_expr;Type of the value.
*)val_recursive : bool;true if the value is recursive.
mutable val_parameters : Odoc_parameter.parameter list;The parameters, if any.
*)mutable val_code : string option;The code of the value, if we had the only the implementation file.
*)mutable val_loc : location;}Representation of a value.
type t_attribute = Odoc_value.t_attribute = {att_value : t_value;an attribute has almost all the same information as a value
*)att_mutable : bool;true if the attribute is mutable.
att_virtual : bool;true if the attribute is virtual.
}Representation of a class attribute.
type t_method = Odoc_value.t_method = {met_value : t_value;a method has almost all the same information as a value
*)met_private : bool;true if the method is private.
met_virtual : bool;true if the method is virtual.
}Representation of a class method.
val is_function : t_value -> boolReturn true if the value is a function, i.e. it has a functional type.
Odoc_infoInterface to the information collected in source files.
type ref_kind = Odoc_types.ref_kind = | RK_module| RK_module_type| RK_class| RK_class_type| RK_value| RK_type| RK_extension| RK_exception| RK_attribute| RK_method| RK_section of text| RK_recfield| RK_constThe different kinds of element references.
and text_element = Odoc_types.text_element = | Raw of stringRaw text.
*)| Code of stringThe string is source code.
*)| CodePre of stringThe string is pre-formatted source code.
*)| Verbatim of stringString 'as is'.
*)| Bold of textText in bold style.
*)| Italic of textText in italic.
*)| Emphasize of textEmphasized text.
*)| Center of textCentered text.
*)| Left of textLeft alignment.
*)| Right of textRight alignment.
*)| List of text listA list.
*)| Enum of text listAn enumerated list.
*)| NewlineTo force a line break.
*)| Block of textLike html's block quote.
*)| Title of int * string option * textStyle number, optional label, and text.
*)| Latex of stringA string for latex.
*)| Link of string * textA reference string and the link text.
*)| Ref of string * ref_kind option * text optionA reference to an element. Complete name and kind. An optional text can be given to display this text instead of the element name.
*)| Superscript of textSuperscripts.
*)| Subscript of textSubscripts.
*)| Module_list of string listThe table of the given modules with their abstract.
*)| Index_listThe links to the various indexes (values, types, ...)
*)| Custom of string * textto extend {foo syntax
*)| Target of string * string(target, code) : to specify code specific to a target format
*)and text = text_element listA text is a list of text_element. The order matters.
The different forms of references in @see tags.
Raised when parsing string to build a Odoc_info.text structure. (line, char, string)
type param = string * textParameter name and description.
type raised_exception = string * textRaised exception name and description.
type info = Odoc_types.info = {i_desc : text option;The description text.
*)i_version : string option;The string in the @version tag.
*)i_sees : see list;The list of @see tags.
*)i_since : string option;The string in the @since tag.
*)i_before : (string * text) list;the version number and text in @before tag
*)i_deprecated : text option;The description text of the @deprecated tag.
*)i_params : param list;The list of parameter descriptions.
*)i_raised_exceptions : raised_exception list;The list of raised exceptions.
*)i_return_value : text option;The description text of the return value.
*)i_custom : (string * text) list;A text associated to a custom @-tag.
*)}Information in a special comment
type location = Odoc_types.location = {loc_impl : Location.t option;implementation location
*)loc_inter : Location.t option;interface location
*)}Location of elements in implementation and interface files.
val dummy_loc : locationA dummy location.
module Name : sig ... endRepresentation of element names.
module Parameter : sig ... endRepresentation and manipulation of method / function / class / module parameters.
module Extension : sig ... endRepresentation and manipulation of extensions.
module Exception : sig ... endRepresentation and manipulation of exceptions.
module Type : sig ... endRepresentation and manipulation of types.
module Value : sig ... endRepresentation and manipulation of values, class attributes and class methods.
module Class : sig ... endRepresentation and manipulation of classes and class types.
module Module : sig ... endRepresentation and manipulation of modules and module types.
This function is used to reset the names of type variables. It must be called when printing the whole type of a function, but not when printing the type of its parameters. Same for classes (call it) and methods and attributes (don't call it).
val string_of_variance : Type.t_type -> (bool * bool) -> stringstring_of_variance t (covariant, invariant) returns "+" if the given information means "covariant", "-" if it means "contravariant", orelse "", and always "" if the given type is not an abstract type with no manifest (i.e. no need for the variance to be printed).
val string_of_type_expr : Types.type_expr -> stringThis function returns a string representing a Types.type_expr.
val string_of_class_params : Class.t_class -> stringval string_of_type_list : ?par:bool -> string -> Types.type_expr list -> stringThis function returns a string to represent the given list of types, with a given separator.
val string_of_type_param_list : Type.t_type -> stringThis function returns a string to represent the list of type parameters for the given type.
val string_of_type_extension_param_list : Extension.t_type_extension -> stringThis function returns a string to represent the list of type parameters for the given type extension.
val string_of_class_type_param_list : Types.type_expr list -> stringThis function returns a string to represent the given list of type parameters of a class or class type, with a given separator.
val string_of_module_type :
+ ?code:string ->
+ ?complete:bool ->
+ Types.module_type ->
+ stringThis function returns a string representing a Types.module_type.
val string_of_class_type : ?complete:bool -> Types.class_type -> stringThis function returns a string representing a Types.class_type.
val string_of_text : text -> stringGet a string from a text.
val string_of_info : info -> stringGet a string from an info structure.
val string_of_type : Type.t_type -> stringval string_of_record : Type.record_field list -> stringval string_of_type_extension : Extension.t_type_extension -> stringval string_of_exception : Exception.t_exception -> stringval string_of_value : Value.t_value -> stringval string_of_attribute : Value.t_attribute -> stringval string_of_method : Value.t_method -> stringReturn the first sentence (until the first dot followed by a blank or the first blank line) of a text. Don't stop in the middle of Code, CodePre, Verbatim, List, Enum, Latex, Link, Ref, Subscript or Superscript.
Return the first sentence (until the first dot followed by a blank or the first blank line) of a text, and the remaining text after. Don't stop in the middle of Code, CodePre, Verbatim, List, Enum, Latex, Link, Ref, Subscript or Superscript.
val text_concat : Odoc_types.text -> Odoc_types.text list -> Odoc_types.textconcat sep l concats the given list of text l, each separated with the text sep.
Return the list of titles in a text. A title is a title level, an optional label and a text.
Take a sorted list of elements, a function to get the name of an element and return the list of list of elements, where each list group elements beginning by the same letter. Since the original list is sorted, elements whose name does not begin with a letter should be in the first returned list.
val remove_option : Types.type_expr -> Types.type_exprTake a type and remove the option top constructor. This is useful when printing labels, we then remove the top option constructor for optional labels.
val is_optional : Asttypes.arg_label -> boolReturn true if the given label is optional.
val label_name : Asttypes.arg_label -> stringReturn the label name for the given label, i.e. removes the beginning '?' if present.
Return the given name where the module name or part of it was removed, according to the list of modules which must be hidden (cf Odoc_args.hidden_modules)
Print a warning message to stderr. If warnings must be treated as errors, then the error counter is incremented.
val print_warnings : bool refA flag to indicate whether ocamldoc warnings must be printed or not.
val errors : int refIncrement this counter when an error is encountered. The ocamldoc tool will print the number of errors encountered exit with code 1 if this number is greater than 0.
Apply a function to a first value if it is not different from a second value. If the two values are different, return the second one.
val text_of_string : string -> texttext_of_string s returns the text structure from the given string.
val text_string_of_text : text -> stringtext_string_of_text text returns the string representing the given text. This string can then be parsed again by Odoc_info.text_of_string.
val info_of_string : string -> infoinfo_of_string s parses the given string like a regular ocamldoc comment and return an Odoc_info.info structure.
val info_string_of_info : info -> stringinfo_string_of_info info returns the string representing the given info. This string can then be parsed again by Odoc_info.info_of_string.
val info_of_comment_file : Module.t_module list -> string -> infoinfo_of_comment_file file parses the given file and return an Odoc_info.info structure. The content of the file must have the same syntax as the content of a special comment. The given module list is used for cross reference.
remove_ending_newline s returns s without the optional ending newline.
module Search : sig ... endResearch in elements
module Scan : sig ... endScanning of collected information
module Dep : sig ... endComputation of dependencies.
module Global : sig ... endval analyse_files :
+ ?merge_options:Odoc_types.merge_option list ->
+ ?include_dirs:string list ->
+ ?labels:bool ->
+ ?sort_modules:bool ->
+ ?no_stop:bool ->
+ ?init:Odoc_module.t_module list ->
+ Odoc_global.source_file list ->
+ Module.t_module listAnalysis of the given source files.
val dump_modules : string -> Odoc_module.t_module list -> unitDump of a list of modules into a file.
val load_modules : string -> Odoc_module.t_module listLoad of a list of modules from a file.
Odoc_inheritGenerator.latexval mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval subst_strings_simple : (Str.regexp * string) listval subst_strings_code : (Str.regexp * string) listval subst_strings : (Str.regexp * string) listmethod attribute_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod const_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod entry_comment : (Format.formatter * (unit -> string)) ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod exception_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod extension_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod first_and_rest_of_info : Odoc_info.info option ->
+ Odoc_info.text * Odoc_info.textmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_top_module : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_inheritance_info : Format.formatter ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod label : ?no_:bool -> Odoc_info.Name.t -> stringmethod latex_for_class_index : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_label : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_type_index : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_class_type_label : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_module_index : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_label : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_type_index : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_for_module_type_label : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_header : Format.formatter ->
+ Odoc_info.Module.t_module list ->
+ unitmethod latex_of_Block : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Bold : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Center : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Code : Format.formatter -> string -> unitmethod latex_of_CodePre : Format.formatter -> string -> unitmethod latex_of_Emphasize : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Enum : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Italic : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Latex : Format.formatter -> string -> unitmethod latex_of_Left : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Link : Format.formatter -> string -> Odoc_info.text -> unitmethod latex_of_List : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Newline : Format.formatter -> unitmethod latex_of_Raw : Format.formatter -> string -> unitmethod latex_of_Ref : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod latex_of_Right : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Subscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Superscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Target : Format.formatter ->
+ target:string ->
+ code:string ->
+ unitmethod latex_of_Title : Format.formatter ->
+ int ->
+ Odoc_info.Name.t option ->
+ Odoc_info.text ->
+ unitmethod latex_of_Verbatim : Format.formatter -> string -> unitmethod latex_of_attribute : Format.formatter ->
+ Odoc_info.Value.t_attribute ->
+ unitmethod latex_of_class : Format.formatter -> Odoc_info.Class.t_class -> unitmethod latex_of_class_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod latex_of_class_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ unitmethod latex_of_class_parameter_list : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_of_class_type : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_of_class_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod latex_of_cstr_args : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Type.constructor_args * Types.type_expr option) ->
+ Odoc_info.text_element listmethod latex_of_custom_text : Format.formatter ->
+ string ->
+ Odoc_info.text ->
+ unitmethod latex_of_exception : Format.formatter ->
+ Odoc_info.Exception.t_exception ->
+ unitmethod latex_of_included_module : Format.formatter ->
+ Odoc_info.Module.included_module ->
+ unitmethod latex_of_info : Format.formatter ->
+ ?block:bool ->
+ Odoc_info.info option ->
+ unitmethod latex_of_method : Format.formatter -> Odoc_info.Value.t_method -> unitmethod latex_of_module : Format.formatter -> Odoc_info.Module.t_module -> unitmethod latex_of_module_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod latex_of_module_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_kind ->
+ unitmethod latex_of_module_parameter : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod latex_of_module_type : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_of_module_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod latex_of_record : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field list ->
+ Odoc_info.text_element listmethod latex_of_text : Format.formatter -> Odoc_info.text -> unitmethod latex_of_text_element : Format.formatter ->
+ Odoc_info.text_element ->
+ unitmethod latex_of_type : Format.formatter -> Odoc_info.Type.t_type -> unitmethod latex_of_type_extension : Odoc_info.Name.t ->
+ Format.formatter ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod latex_of_type_params : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod latex_of_value : Format.formatter -> Odoc_info.Value.t_value -> unitmethod method_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod recfield_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod subst : (Str.regexp * string) list -> string -> stringmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool -> Odoc_info.info option -> Odoc_info.textmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listmethod type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod value_label : ?no_:bool -> Odoc_info.Name.t -> stringOdoc_latex.Generatorclass latex : object ... endOdoc_latex.infomethod latex_of_info : Format.formatter ->
+ ?block:bool ->
+ Odoc_info.info option ->
+ unitmethod latex_of_text : Format.formatter -> Odoc_info.text -> unitmethod text_of_info : ?block:bool -> Odoc_info.info option -> Odoc_info.textOdoc_latex.textval subst_strings_simple : (Str.regexp * string) listval subst_strings_code : (Str.regexp * string) listval subst_strings : (Str.regexp * string) listmethod attribute_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod const_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod exception_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod extension_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod label : ?no_:bool -> Odoc_info.Name.t -> stringmethod latex_of_Block : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Bold : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Center : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Code : Format.formatter -> string -> unitmethod latex_of_CodePre : Format.formatter -> string -> unitmethod latex_of_Emphasize : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Enum : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Italic : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Latex : Format.formatter -> string -> unitmethod latex_of_Left : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Link : Format.formatter -> string -> Odoc_info.text -> unitmethod latex_of_List : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Newline : Format.formatter -> unitmethod latex_of_Raw : Format.formatter -> string -> unitmethod latex_of_Ref : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod latex_of_Right : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Subscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Superscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Target : Format.formatter ->
+ target:string ->
+ code:string ->
+ unitmethod latex_of_Title : Format.formatter ->
+ int ->
+ Odoc_info.Name.t option ->
+ Odoc_info.text ->
+ unitmethod latex_of_Verbatim : Format.formatter -> string -> unitmethod latex_of_custom_text : Format.formatter ->
+ string ->
+ Odoc_info.text ->
+ unitmethod latex_of_text : Format.formatter -> Odoc_info.text -> unitmethod latex_of_text_element : Format.formatter ->
+ Odoc_info.text_element ->
+ unitmethod method_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod recfield_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod subst : (Str.regexp * string) list -> string -> stringmethod type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod value_label : ?no_:bool -> Odoc_info.Name.t -> stringOdoc_latexval separate_files : bool refval latex_titles : (int * string) list refval latex_value_prefix : string refval latex_type_prefix : string refval latex_type_elt_prefix : string refval latex_extension_prefix : string refval latex_exception_prefix : string refval latex_module_prefix : string refval latex_module_type_prefix : string refval latex_class_prefix : string refval latex_class_type_prefix : string refval latex_attribute_prefix : string refval latex_method_prefix : string refval new_buf : unit -> Stdlib.Buffer.tval new_fmt : unit -> Stdlib.Format.formatter * (unit -> string)val p :
+ Stdlib.Format.formatter ->
+ ('a, Stdlib.Format.formatter, unit) format ->
+ 'aval ps : Stdlib.Format.formatter -> string -> unitval bp : Stdlib.Buffer.t -> ('a, Stdlib.Buffer.t, unit) format -> 'aval bs : Stdlib.Buffer.t -> string -> unitval merge_codepre : Odoc_info.text_element list -> Odoc_info.text_element listval print_concat :
+ Stdlib.Format.formatter ->
+ string ->
+ ('a -> unit) ->
+ 'a list ->
+ unitclass text : object ... endclass virtual info : object ... endmodule Generator : sig ... endmodule type Latex_generator = sig ... endLatex_generator.latexval mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval subst_strings_simple : (Str.regexp * string) listval subst_strings_code : (Str.regexp * string) listval subst_strings : (Str.regexp * string) listmethod attribute_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod class_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod const_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod entry_comment : (Format.formatter * (unit -> string)) ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod exception_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod extension_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod first_and_rest_of_info : Odoc_info.info option ->
+ Odoc_info.text * Odoc_info.textmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_top_module : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod generate_inheritance_info : Format.formatter ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod label : ?no_:bool -> Odoc_info.Name.t -> stringmethod latex_for_class_index : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_label : Format.formatter ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_for_class_type_index : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_class_type_label : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_for_module_index : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_label : Format.formatter ->
+ Odoc_info.Module.t_module ->
+ unitmethod latex_for_module_type_index : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_for_module_type_label : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_header : Format.formatter ->
+ Odoc_info.Module.t_module list ->
+ unitmethod latex_of_Block : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Bold : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Center : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Code : Format.formatter -> string -> unitmethod latex_of_CodePre : Format.formatter -> string -> unitmethod latex_of_Emphasize : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Enum : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Italic : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Latex : Format.formatter -> string -> unitmethod latex_of_Left : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Link : Format.formatter -> string -> Odoc_info.text -> unitmethod latex_of_List : Format.formatter -> Odoc_info.text list -> unitmethod latex_of_Newline : Format.formatter -> unitmethod latex_of_Raw : Format.formatter -> string -> unitmethod latex_of_Ref : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.text option ->
+ unitmethod latex_of_Right : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Subscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Superscript : Format.formatter -> Odoc_info.text -> unitmethod latex_of_Target : Format.formatter ->
+ target:string ->
+ code:string ->
+ unitmethod latex_of_Title : Format.formatter ->
+ int ->
+ Odoc_info.Name.t option ->
+ Odoc_info.text ->
+ unitmethod latex_of_Verbatim : Format.formatter -> string -> unitmethod latex_of_attribute : Format.formatter ->
+ Odoc_info.Value.t_attribute ->
+ unitmethod latex_of_class : Format.formatter -> Odoc_info.Class.t_class -> unitmethod latex_of_class_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ unitmethod latex_of_class_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ unitmethod latex_of_class_parameter_list : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ unitmethod latex_of_class_type : Format.formatter ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod latex_of_class_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ unitmethod latex_of_cstr_args : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Type.constructor_args * Types.type_expr option) ->
+ Odoc_info.text_element listmethod latex_of_custom_text : Format.formatter ->
+ string ->
+ Odoc_info.text ->
+ unitmethod latex_of_exception : Format.formatter ->
+ Odoc_info.Exception.t_exception ->
+ unitmethod latex_of_included_module : Format.formatter ->
+ Odoc_info.Module.included_module ->
+ unitmethod latex_of_info : Format.formatter ->
+ ?block:bool ->
+ Odoc_info.info option ->
+ unitmethod latex_of_method : Format.formatter -> Odoc_info.Value.t_method -> unitmethod latex_of_module : Format.formatter -> Odoc_info.Module.t_module -> unitmethod latex_of_module_element : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ unitmethod latex_of_module_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_kind ->
+ unitmethod latex_of_module_parameter : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_parameter ->
+ unitmethod latex_of_module_type : Format.formatter ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod latex_of_module_type_kind : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.module_type_kind ->
+ unitmethod latex_of_record : (Format.formatter * (unit -> string)) ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field list ->
+ Odoc_info.text_element listmethod latex_of_text : Format.formatter -> Odoc_info.text -> unitmethod latex_of_text_element : Format.formatter ->
+ Odoc_info.text_element ->
+ unitmethod latex_of_type : Format.formatter -> Odoc_info.Type.t_type -> unitmethod latex_of_type_extension : Odoc_info.Name.t ->
+ Format.formatter ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod latex_of_type_params : Format.formatter ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod latex_of_value : Format.formatter -> Odoc_info.Value.t_value -> unitmethod method_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod module_type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod recfield_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod subst : (Str.regexp * string) list -> string -> stringmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool -> Odoc_info.info option -> Odoc_info.textmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listmethod type_label : ?no_:bool -> Odoc_info.Name.t -> stringmethod value_label : ?no_:bool -> Odoc_info.Name.t -> stringOdoc_latex.Latex_generatorclass latex : object ... endOdoc_latex_styleOdoc_lexerval line_number : int refval string_buffer : Stdlib.Buffer.tval description : string refval comments_level : int refval main : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_main_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenval special_comment : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_special_comment_rec :
+ Stdlib.Lexing.lexbuf ->
+ int ->
+ Odoc_parser.tokenval special_comment_part2 : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_special_comment_part2_rec :
+ Stdlib.Lexing.lexbuf ->
+ int ->
+ Odoc_parser.tokenval elements : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_elements_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenval simple : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_simple_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenGenerator.manval mutable tag_functions : (string * (Odoc_info.text -> string)) listmethod create_groups : bool ->
+ Odoc_info.Module.t_module list ->
+ Odoc_info.Search.result_element list listmethod field_comment : Buffer.t -> Odoc_info.info option -> unitmethod file_name : Odoc_info.Name.t -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class -> unitmethod generate_for_class_type : Odoc_info.Class.t_class_type -> unitmethod generate_for_group : Odoc_info.Search.result_element list -> unitmethod generate_for_module : Odoc_info.Module.t_module -> unitmethod generate_for_module_type : Odoc_info.Module.t_module_type -> unitmethod man_of_Target : Buffer.t -> target:string -> code:string -> unitmethod man_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod man_of_class : Buffer.t -> Odoc_info.Class.t_class -> unitmethod man_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_class_type : Buffer.t -> Odoc_info.Class.t_class_type -> unitmethod man_of_class_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.class_type ->
+ unitmethod man_of_code : Buffer.t -> string -> unitmethod man_of_const : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.variant_constructor ->
+ unitmethod man_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod man_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod man_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod man_of_included_module : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod man_of_info : ?margin:int -> Buffer.t -> Odoc_types.info option -> unitmethod man_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod man_of_modtype : Buffer.t -> Odoc_info.Module.t_module_type -> unitmethod man_of_module : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_body : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod man_of_module_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod man_of_module_type_body : Buffer.t ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod man_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod man_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ unitmethod man_of_recfield : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field ->
+ unitmethod man_of_record : Odoc_info.Name.t ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod man_of_text : Buffer.t -> Odoc_info.text -> unitmethod man_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod man_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod man_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod man_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod man_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod man_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod open_out : string -> out_channelmethod relative_idents : Odoc_info.Name.t -> Odoc_info.Name.t -> stringmethod str_man_of_before : (string * Odoc_info.text) list -> stringmethod str_man_of_custom : (string * Odoc_info.text) list -> string listmethod str_man_of_raised_exceptions : (string * Odoc_info.text) list -> stringmethod str_man_of_return_opt : Odoc_info.text option -> stringmethod str_man_of_see : (Odoc_info.see_ref * Odoc_info.text) -> stringmethod str_man_of_sees : (Odoc_info.see_ref * Odoc_info.text) list -> stringmethod str_man_of_text : Odoc_info.text -> stringOdoc_man.Generatorclass man : object ... endOdoc_man.infoval mutable tag_functions : (string * (Odoc_info.text -> string)) listmethod man_of_info : ?margin:int -> Buffer.t -> Odoc_types.info option -> unitmethod man_of_text : Buffer.t -> Odoc_info.text -> unitmethod str_man_of_before : (string * Odoc_info.text) list -> stringmethod str_man_of_custom : (string * Odoc_info.text) list -> string listmethod str_man_of_raised_exceptions : (string * Odoc_info.text) list -> stringmethod str_man_of_return_opt : Odoc_info.text option -> stringmethod str_man_of_see : (Odoc_info.see_ref * Odoc_info.text) -> stringmethod str_man_of_sees : (Odoc_info.see_ref * Odoc_info.text) list -> stringmethod str_man_of_text : Odoc_info.text -> stringOdoc_manval man_suffix : string refval man_section : string refval man_mini : bool refval new_buf : unit -> Stdlib.Buffer.tval bp : Stdlib.Buffer.t -> ('a, Stdlib.Buffer.t, unit) format -> 'aval bs : Stdlib.Buffer.t -> string -> unitclass virtual info : object ... endmodule Generator : sig ... endmodule type Man_generator = sig ... endMan_generator.manval mutable tag_functions : (string * (Odoc_info.text -> string)) listmethod create_groups : bool ->
+ Odoc_info.Module.t_module list ->
+ Odoc_info.Search.result_element list listmethod field_comment : Buffer.t -> Odoc_info.info option -> unitmethod file_name : Odoc_info.Name.t -> stringmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_for_class : Odoc_info.Class.t_class -> unitmethod generate_for_class_type : Odoc_info.Class.t_class_type -> unitmethod generate_for_group : Odoc_info.Search.result_element list -> unitmethod generate_for_module : Odoc_info.Module.t_module -> unitmethod generate_for_module_type : Odoc_info.Module.t_module_type -> unitmethod man_of_Target : Buffer.t -> target:string -> code:string -> unitmethod man_of_attribute : Buffer.t -> Odoc_info.Value.t_attribute -> unitmethod man_of_class : Buffer.t -> Odoc_info.Class.t_class -> unitmethod man_of_class_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_class_type : Buffer.t -> Odoc_info.Class.t_class_type -> unitmethod man_of_class_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.class_type ->
+ unitmethod man_of_code : Buffer.t -> string -> unitmethod man_of_const : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.variant_constructor ->
+ unitmethod man_of_cstr_args : ?par:bool ->
+ Buffer.t ->
+ Odoc_info.Name.t ->
+ string ->
+ Odoc_info.Type.constructor_args ->
+ unitmethod man_of_custom_text : Buffer.t -> string -> Odoc_info.text -> unitmethod man_of_exception : Buffer.t -> Odoc_info.Exception.t_exception -> unitmethod man_of_included_module : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Module.included_module ->
+ unitmethod man_of_info : ?margin:int -> Buffer.t -> Odoc_types.info option -> unitmethod man_of_method : Buffer.t -> Odoc_info.Value.t_method -> unitmethod man_of_modtype : Buffer.t -> Odoc_info.Module.t_module_type -> unitmethod man_of_module : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_body : Buffer.t -> Odoc_info.Module.t_module -> unitmethod man_of_module_comment : Buffer.t -> Odoc_info.text -> unitmethod man_of_module_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ (Odoc_info.Module.module_parameter * Odoc_info.text option) list ->
+ unitmethod man_of_module_type : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ unitmethod man_of_module_type_body : Buffer.t ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod man_of_parameter_description : Buffer.t ->
+ Odoc_info.Parameter.parameter ->
+ unitmethod man_of_parameter_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ unitmethod man_of_recfield : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.record_field ->
+ unitmethod man_of_record : Odoc_info.Name.t ->
+ Buffer.t ->
+ Odoc_info.Type.record_field list ->
+ unitmethod man_of_text : Buffer.t -> Odoc_info.text -> unitmethod man_of_text_element : Buffer.t -> Odoc_info.text_element -> unitmethod man_of_type : Buffer.t -> Odoc_info.Type.t_type -> unitmethod man_of_type_expr : Buffer.t ->
+ Odoc_info.Name.t ->
+ Types.type_expr ->
+ unitmethod man_of_type_expr_param_list : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.t_type ->
+ unitmethod man_of_type_extension : Buffer.t ->
+ Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ unitmethod man_of_value : Buffer.t -> Odoc_info.Value.t_value -> unitmethod open_out : string -> out_channelmethod relative_idents : Odoc_info.Name.t -> Odoc_info.Name.t -> stringmethod str_man_of_before : (string * Odoc_info.text) list -> stringmethod str_man_of_custom : (string * Odoc_info.text) list -> string listmethod str_man_of_raised_exceptions : (string * Odoc_info.text) list -> stringmethod str_man_of_return_opt : Odoc_info.text option -> stringmethod str_man_of_see : (Odoc_info.see_ref * Odoc_info.text) -> stringmethod str_man_of_sees : (Odoc_info.see_ref * Odoc_info.text) list -> stringmethod str_man_of_text : Odoc_info.text -> stringOdoc_man.Man_generatorclass man : object ... endOdoc_mergeval merge_before_tags :
+ (string * Odoc_types.text) list ->
+ (string * Odoc_types.text) listval merge_info_opt :
+ Odoc_types.merge_option list ->
+ Odoc_types.info option ->
+ Odoc_types.info option ->
+ Odoc_types.info optionval merge :
+ Odoc_types.merge_option list ->
+ Odoc_module.t_module list ->
+ Odoc_module.t_module listOdoc_messagesval latex_title : (int * string) list ref -> stringval texinfo_title : (int * (string * string)) list ref -> stringOdoc_miscval string_of_longident : Longident.t -> stringval string_of_text : Odoc_types.text -> stringval string_of_raised_exceptions : (string * Odoc_types.text) list -> stringval string_of_see : (Odoc_types.see_ref * Odoc_types.text) -> stringval string_of_sees : (Odoc_types.see_ref * Odoc_types.text) list -> stringval string_of_return_opt : Odoc_types.text option -> stringval string_of_info : Odoc_types.info -> stringval first_sentence_of_text : Odoc_types.text -> Odoc_types.textval first_sentence_and_rest_of_text :
+ Odoc_types.text ->
+ Odoc_types.text * Odoc_types.textval text_no_title_no_list : Odoc_types.text -> Odoc_types.textval text_concat : Odoc_types.text -> Odoc_types.text list -> Odoc_types.textval get_titles_in_text :
+ Odoc_types.text ->
+ (int * string option * Odoc_types.text) listval remove_option : Types.type_expr -> Types.type_exprval is_optional : Asttypes.arg_label -> boolval label_name : Asttypes.arg_label -> stringOdoc_modulemodule String = Misc.Stdlib.Stringmodule Name = Odoc_nametype module_element = | Element_module of t_module| Element_module_type of t_module_type| Element_included_module of included_module| Element_class of Odoc_class.t_class| Element_class_type of Odoc_class.t_class_type| Element_value of Odoc_value.t_value| Element_type_extension of Odoc_extension.t_type_extension| Element_exception of Odoc_exception.t_exception| Element_type of Odoc_type.t_type| Element_module_comment of Odoc_types.textand included_module = {im_name : Name.t;mutable im_module : mmt option;mutable im_info : Odoc_types.info option;}and module_parameter = {mp_name : string;mp_type : Types.module_type option;mp_type_code : string;mp_kind : module_type_kind;}and module_kind = | Module_struct of module_element list| Module_alias of module_alias| Module_functor of module_parameter * module_kind| Module_apply of module_kind * module_kind| Module_with of module_type_kind * string| Module_constraint of module_kind * module_type_kind| Module_typeof of string| Module_unpack of string * module_type_aliasand t_module = {m_name : Name.t;mutable m_type : Types.module_type;mutable m_info : Odoc_types.info option;m_is_interface : bool;m_file : string;mutable m_kind : module_kind;mutable m_loc : Odoc_types.location;mutable m_top_deps : Name.t list;mutable m_code : string option;mutable m_code_intf : string option;m_text_only : bool;}and module_type_kind = | Module_type_struct of module_element list| Module_type_functor of module_parameter * module_type_kind| Module_type_alias of module_type_alias| Module_type_with of module_type_kind * string| Module_type_typeof of stringand t_module_type = {mt_name : Name.t;mutable mt_info : Odoc_types.info option;mutable mt_type : Types.module_type option;mt_is_interface : bool;mt_file : string;mutable mt_kind : module_type_kind option;mutable mt_loc : Odoc_types.location;}val values : module_element list -> Odoc_value.t_value listval types : module_element list -> Odoc_type.t_type listval type_extensions :
+ module_element list ->
+ Odoc_extension.t_type_extension listval exceptions : module_element list -> Odoc_exception.t_exception listval classes : module_element list -> Odoc_class.t_class listval class_types : module_element list -> Odoc_class.t_class_type listval modules : module_element list -> t_module listval mod_types : module_element list -> t_module_type listval comments : module_element list -> Odoc_types.text listval included_modules : module_element list -> included_module listval module_type_elements : ?trans:bool -> t_module_type -> module_element listval module_elements : ?trans:bool -> t_module -> module_element listval module_values : ?trans:bool -> t_module -> Odoc_value.t_value listval module_functions : ?trans:bool -> t_module -> Odoc_value.t_value listval module_simple_values : ?trans:bool -> t_module -> Odoc_value.t_value listval module_types : ?trans:bool -> t_module -> Odoc_type.t_type listval module_type_extensions :
+ ?trans:bool ->
+ t_module ->
+ Odoc_extension.t_type_extension listval module_exceptions :
+ ?trans:bool ->
+ t_module ->
+ Odoc_exception.t_exception listval module_classes : ?trans:bool -> t_module -> Odoc_class.t_class listval module_class_types :
+ ?trans:bool ->
+ t_module ->
+ Odoc_class.t_class_type listval module_module_types : ?trans:bool -> t_module -> t_module_type listval module_included_modules : ?trans:bool -> t_module -> included_module listval module_comments : ?trans:bool -> t_module -> Odoc_types.text listval module_type_parameters :
+ ?trans:bool ->
+ t_module_type ->
+ (module_parameter * Odoc_types.text option) listval module_parameters :
+ ?trans:bool ->
+ t_module ->
+ (module_parameter * Odoc_types.text option) listval module_type_is_functor : t_module_type -> boolval module_is_functor : t_module -> boolval module_type_values :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_value.t_value listval module_type_types : ?trans:bool -> t_module_type -> Odoc_type.t_type listval module_type_type_extensions :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_extension.t_type_extension listval module_type_exceptions :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_exception.t_exception listval module_type_classes :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_class.t_class listval module_type_class_types :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_class.t_class_type listval module_type_modules : ?trans:bool -> t_module_type -> t_module listval module_type_module_types :
+ ?trans:bool ->
+ t_module_type ->
+ t_module_type listval module_type_included_modules :
+ ?trans:bool ->
+ t_module_type ->
+ included_module listval module_type_comments : ?trans:bool -> t_module_type -> Odoc_types.text listval module_type_functions :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_value.t_value listval module_type_simple_values :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_value.t_value listval module_all_classes : ?trans:bool -> t_module -> Odoc_class.t_class listval module_type_all_classes :
+ ?trans:bool ->
+ t_module_type ->
+ Odoc_class.t_class listOdoc_name.Maptype key = tval empty : 'a tval is_empty : 'a t -> boolval cardinal : 'a t -> intval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tval add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tOdoc_nameval depth : t -> intval qualified : t -> boolval from_longident : Longident.t -> tmodule Map : sig ... endOdoc_ocamlhtmlexception Error of error * int * intval pre : bool refval fmt : Stdlib.Format.formatter refval create_hashtable : int -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.tval html_of_comment : (string -> string) refval keyword_table : (string, string) Stdlib.Hashtbl.tval margin : int refval comment_buffer : Stdlib.Buffer.tval string_buffer : Stdlib.Buffer.tval char_for_decimal_code : Stdlib.Lexing.lexbuf -> int -> charval char_for_hexa_code : Stdlib.Lexing.lexbuf -> int -> charval string_start_pos : int refval comment_start_pos : int list refval report_error : Stdlib.Format.formatter -> error -> unitval token : Stdlib.Lexing.lexbuf -> unitval __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> unitval comment : Stdlib.Lexing.lexbuf -> unitval __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> unitval string : Stdlib.Lexing.lexbuf -> unitval __ocaml_lex_string_rec : Stdlib.Lexing.lexbuf -> int -> unitval html_of_code : Stdlib.Buffer.t -> ?with_pre:bool -> string -> unitOdoc_parametertype simple_name = {sn_name : string;sn_type : Types.type_expr;mutable sn_text : Odoc_types.text option;}type parameter = param_infoval complete_name : param_info -> stringval typ : param_info -> Types.type_exprval update_parameter_text :
+ (string -> Odoc_types.text option) ->
+ param_info ->
+ unitval desc_by_name : param_info -> string -> Odoc_types.text optionval names : param_info -> string listval type_by_name : param_info -> string -> Types.type_exprval desc_from_info_opt :
+ Odoc_types.info option ->
+ string ->
+ Odoc_types.text optionOdoc_parserval main :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ (string * string option) optionval info_part2 :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ unitval see_info :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Odoc_types.see_ref * stringOdoc_printval string_of_type_expr : Types.type_expr -> stringval string_of_module_type :
+ ?code:string ->
+ ?complete:bool ->
+ Types.module_type ->
+ stringval string_of_class_type : ?complete:bool -> Types.class_type -> stringOdoc_scan.scannermethod scan_attribute : Odoc_value.t_attribute -> unitmethod scan_class : Odoc_class.t_class -> unitmethod scan_class_comment : Odoc_types.text -> unitmethod scan_class_elements : Odoc_class.t_class -> unitmethod scan_class_pre : Odoc_class.t_class -> boolmethod scan_class_type : Odoc_class.t_class_type -> unitmethod scan_class_type_comment : Odoc_types.text -> unitmethod scan_class_type_elements : Odoc_class.t_class_type -> unitmethod scan_class_type_pre : Odoc_class.t_class_type -> boolmethod scan_exception : Odoc_exception.t_exception -> unitmethod scan_extension_constructor : Odoc_extension.t_extension_constructor ->
+ unitmethod scan_included_module : Odoc_module.included_module -> unitmethod scan_method : Odoc_value.t_method -> unitmethod scan_module : Odoc_module.t_module -> unitmethod scan_module_comment : Odoc_types.text -> unitmethod scan_module_elements : Odoc_module.t_module -> unitmethod scan_module_list : Odoc_module.t_module list -> unitmethod scan_module_pre : Odoc_module.t_module -> boolmethod scan_module_type : Odoc_module.t_module_type -> unitmethod scan_module_type_comment : Odoc_types.text -> unitmethod scan_module_type_elements : Odoc_module.t_module_type -> unitmethod scan_module_type_pre : Odoc_module.t_module_type -> boolmethod scan_type : Odoc_type.t_type -> unitmethod scan_type_const : Odoc_type.t_type ->
+ Odoc_type.variant_constructor ->
+ unitmethod scan_type_extension : Odoc_extension.t_type_extension -> unitmethod scan_type_extension_constructors : Odoc_extension.t_type_extension ->
+ unitmethod scan_type_extension_pre : Odoc_extension.t_type_extension -> boolmethod scan_type_pre : Odoc_type.t_type -> boolmethod scan_type_recfield : Odoc_type.t_type -> Odoc_type.record_field -> unitmethod scan_value : Odoc_value.t_value -> unitOdoc_scanclass scanner : object ... endOdoc_search.P_nametype t = Str.regexpval (=~) : string -> Str.regexp -> boolval p_module : Odoc_module.t_module -> Str.regexp -> bool * boolval p_module_type : Odoc_module.t_module_type -> Str.regexp -> bool * boolval p_class : Odoc_class.t_class -> Str.regexp -> bool * boolval p_class_type : Odoc_class.t_class_type -> Str.regexp -> bool * boolval p_value : Odoc_value.t_value -> Str.regexp -> boolval p_recfield :
+ Odoc_type.t_type ->
+ Odoc_type.record_field ->
+ Str.regexp ->
+ boolval p_const :
+ Odoc_type.t_type ->
+ Odoc_type.variant_constructor ->
+ Str.regexp ->
+ boolval p_type : Odoc_type.t_type -> Str.regexp -> bool * boolval p_extension : Odoc_extension.t_extension_constructor -> Str.regexp -> boolval p_exception : Odoc_exception.t_exception -> Str.regexp -> boolval p_attribute : Odoc_value.t_attribute -> Str.regexp -> boolval p_method : Odoc_value.t_method -> Str.regexp -> boolSearch.Pval p_module : Odoc_module.t_module -> t -> bool * boolval p_module_type : Odoc_module.t_module_type -> t -> bool * boolval p_class : Odoc_class.t_class -> t -> bool * boolval p_class_type : Odoc_class.t_class_type -> t -> bool * boolval p_value : Odoc_value.t_value -> t -> boolval p_recfield : Odoc_type.t_type -> Odoc_type.record_field -> t -> boolval p_const : Odoc_type.t_type -> Odoc_type.variant_constructor -> t -> boolval p_type : Odoc_type.t_type -> t -> bool * boolval p_extension : Odoc_extension.t_extension_constructor -> t -> boolval p_exception : Odoc_exception.t_exception -> t -> boolval p_attribute : Odoc_value.t_attribute -> t -> boolval p_method : Odoc_value.t_method -> t -> boolval p_section : string -> t -> boolOdoc_search.Searchmodule P : Predicatesval search_section : Odoc_types.text -> string -> P.t -> result_element listval search_value : Odoc_value.t_value -> P.t -> result_element listval search_recfield :
+ Odoc_type.t_type ->
+ Odoc_type.record_field ->
+ P.t ->
+ result_element listval search_const :
+ Odoc_type.t_type ->
+ Odoc_type.variant_constructor ->
+ P.t ->
+ result_element listval search_type : Odoc_type.t_type -> P.t -> result_element listval search_extension_constructor :
+ Odoc_extension.t_extension_constructor ->
+ P.t ->
+ result_element listval search_type_extension :
+ Odoc_extension.t_type_extension ->
+ P.t ->
+ result_element listval search_exception : Odoc_exception.t_exception -> P.t -> result_element listval search_attribute : Odoc_value.t_attribute -> P.t -> result_element listval search_method : Odoc_value.t_method -> P.t -> result_element listval search_class : Odoc_class.t_class -> P.t -> result_element listval search_class_type : Odoc_class.t_class_type -> P.t -> result_element listval search_module_type :
+ Odoc_module.t_module_type ->
+ P.t ->
+ result_element listval search_module : Odoc_module.t_module -> P.t -> result_element listval search : Odoc_module.t_module list -> P.t -> result_element listOdoc_search.Search_by_nameval search_section :
+ Odoc_types.text ->
+ string ->
+ P_name.t ->
+ result_element listval search_value : Odoc_value.t_value -> P_name.t -> result_element listval search_recfield :
+ Odoc_type.t_type ->
+ Odoc_type.record_field ->
+ P_name.t ->
+ result_element listval search_const :
+ Odoc_type.t_type ->
+ Odoc_type.variant_constructor ->
+ P_name.t ->
+ result_element listval search_type : Odoc_type.t_type -> P_name.t -> result_element listval search_extension_constructor :
+ Odoc_extension.t_extension_constructor ->
+ P_name.t ->
+ result_element listval search_type_extension :
+ Odoc_extension.t_type_extension ->
+ P_name.t ->
+ result_element listval search_exception :
+ Odoc_exception.t_exception ->
+ P_name.t ->
+ result_element listval search_attribute :
+ Odoc_value.t_attribute ->
+ P_name.t ->
+ result_element listval search_method : Odoc_value.t_method -> P_name.t -> result_element listval search_class : Odoc_class.t_class -> P_name.t -> result_element listval search_class_type :
+ Odoc_class.t_class_type ->
+ P_name.t ->
+ result_element listval search_module_type :
+ Odoc_module.t_module_type ->
+ P_name.t ->
+ result_element listval search_module : Odoc_module.t_module -> P_name.t -> result_element listval search : Odoc_module.t_module list -> P_name.t -> result_element listOdoc_searchtype result_element = | Res_module of Odoc_module.t_module| Res_module_type of Odoc_module.t_module_type| Res_class of Odoc_class.t_class| Res_class_type of Odoc_class.t_class_type| Res_value of Odoc_value.t_value| Res_type of Odoc_type.t_type| Res_extension of Odoc_extension.t_extension_constructor| Res_exception of Odoc_exception.t_exception| Res_attribute of Odoc_value.t_attribute| Res_method of Odoc_value.t_method| Res_section of string * Odoc_types.text| Res_recfield of Odoc_type.t_type * Odoc_type.record_field| Res_const of Odoc_type.t_type * Odoc_type.variant_constructortype result = result_element listmodule type Predicates = sig ... endmodule Search (P : Predicates) : sig ... endmodule P_name : sig ... endmodule Search_by_name : sig ... endval values : Odoc_module.t_module list -> Odoc_value.t_value listval extensions :
+ Odoc_module.t_module list ->
+ Odoc_extension.t_extension_constructor listval exceptions : Odoc_module.t_module list -> Odoc_exception.t_exception listval types : Odoc_module.t_module list -> Odoc_type.t_type listval attributes : Odoc_module.t_module list -> Odoc_value.t_attribute listval methods : Odoc_module.t_module list -> Odoc_value.t_method listval classes : Odoc_module.t_module list -> Odoc_class.t_class listval class_types : Odoc_module.t_module list -> Odoc_class.t_class_type listval modules : Odoc_module.t_module list -> Odoc_module.t_module listval module_types : Odoc_module.t_module list -> Odoc_module.t_module_type listval type_exists : Odoc_module.t_module list -> Str.regexp -> boolval value_exists : Odoc_module.t_module list -> Str.regexp -> boolval module_exists : Odoc_module.t_module list -> Str.regexp -> boolval module_type_exists : Odoc_module.t_module list -> Str.regexp -> boolval class_exists : Odoc_module.t_module list -> Str.regexp -> boolval class_type_exists : Odoc_module.t_module list -> Str.regexp -> boolval extension_exists : Odoc_module.t_module list -> Str.regexp -> boolval exception_exists : Odoc_module.t_module list -> Str.regexp -> boolval attribute_exists : Odoc_module.t_module list -> Str.regexp -> boolval method_exists : Odoc_module.t_module list -> Str.regexp -> boolval find_section : Odoc_module.t_module list -> Str.regexp -> Odoc_types.textOdoc_search.Predicatesval p_module : Odoc_module.t_module -> t -> bool * boolval p_module_type : Odoc_module.t_module_type -> t -> bool * boolval p_class : Odoc_class.t_class -> t -> bool * boolval p_class_type : Odoc_class.t_class_type -> t -> bool * boolval p_value : Odoc_value.t_value -> t -> boolval p_recfield : Odoc_type.t_type -> Odoc_type.record_field -> t -> boolval p_const : Odoc_type.t_type -> Odoc_type.variant_constructor -> t -> boolval p_type : Odoc_type.t_type -> t -> bool * boolval p_extension : Odoc_extension.t_extension_constructor -> t -> boolval p_exception : Odoc_exception.t_exception -> t -> boolval p_attribute : Odoc_value.t_attribute -> t -> boolval p_method : Odoc_value.t_method -> t -> boolval p_section : string -> t -> boolOdoc_see_lexerval buf : Stdlib.Buffer.tval main : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_main_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenval url : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_url_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenval doc : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_doc_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenval file : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_file_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenval desc : Stdlib.Lexing.lexbuf -> Odoc_parser.tokenval __ocaml_lex_desc_rec : Stdlib.Lexing.lexbuf -> int -> Odoc_parser.tokenAnalyser._val all_special : string -> string -> int * Odoc_types.info listval just_after_special : string -> string -> int * Odoc_types.info optionval first_special : string -> string -> int * Odoc_types.info optionval get_comments :
+ (Odoc_types.text -> 'a) ->
+ string ->
+ string ->
+ Odoc_types.info option * 'a listOdoc_sig.Analysermodule _ : Info_retrieverval file : string refval file_name : string refval preamble :
+ string ->
+ string ->
+ ('a -> Location.t) ->
+ 'a list ->
+ int * Odoc_types.info optionval get_comments_in_class :
+ int ->
+ int ->
+ Odoc_types.info option * Odoc_class.class_element listval get_comments_in_module :
+ int ->
+ int ->
+ Odoc_types.info option * Odoc_module.module_element listval name_comment_from_type_decl :
+ int ->
+ int ->
+ Parsetree.type_declaration ->
+ int * (string * Odoc_types.info option) listval manifest_structure :
+ Odoc_env.env ->
+ (string * Odoc_types.info option) list ->
+ Types.type_expr ->
+ Odoc_type.type_manifestval get_type_kind :
+ Odoc_env.env ->
+ (string * Odoc_types.info option) list ->
+ Types.type_decl_kind ->
+ Odoc_type.type_kindval get_cstr_args :
+ Odoc_env.env ->
+ int ->
+ Typedtree.constructor_arguments ->
+ Odoc_type.constructor_argsval merge_infos :
+ Odoc_types.info option ->
+ Odoc_types.info option ->
+ Odoc_types.info optionval analyse_module_type_kind :
+ ?erased:
+ [ `Constrained of Parsetree.with_constraint list | `Removed ]
+ Odoc_name.Map.t ->
+ Odoc_env.env ->
+ Odoc_name.t ->
+ Parsetree.module_type ->
+ Types.module_type ->
+ Odoc_module.module_type_kindval analyse_class_type_kind :
+ Odoc_env.env ->
+ Odoc_name.t ->
+ int ->
+ Parsetree.class_type ->
+ Types.class_type ->
+ Odoc_class.class_type_kindval analyse_signature :
+ string ->
+ string ->
+ Parsetree.signature ->
+ Types.signature ->
+ Odoc_module.t_moduleOdoc_sig.Signature_searchtype tab = (ele, Types.signature_item) Stdlib.Hashtbl.tval table : Types.signature -> tabval search_value : tab -> string -> Types.type_exprval search_extension : tab -> string -> Types.extension_constructorval search_type : tab -> string -> Types.type_declarationval search_class : tab -> string -> Types.class_declarationval search_class_type : tab -> string -> Types.class_type_declarationval search_module : tab -> string -> Types.module_typeval search_module_type : tab -> string -> Types.module_type optionval search_attribute_type :
+ Types.Vars.key ->
+ Types.class_signature ->
+ Types.type_exprval search_method_type : string -> Types.class_signature -> Types.type_exprOdoc_sigmodule Signature_search : sig ... endmodule type Info_retriever = sig ... endmodule Analyser (_ : Info_retriever) : sig ... endOdoc_sig.Info_retrieverval all_special : string -> string -> int * Odoc_types.info listval just_after_special : string -> string -> int * Odoc_types.info optionval first_special : string -> string -> int * Odoc_types.info optionval get_comments :
+ (Odoc_types.text -> 'a) ->
+ string ->
+ string ->
+ Odoc_types.info option * 'a listOdoc_strval string_of_variance : Odoc_type.t_type -> (bool * bool) -> stringval string_of_type_list : ?par:bool -> string -> Types.type_expr list -> stringval string_of_type_param_list : Odoc_type.t_type -> stringval string_of_type_extension_param_list :
+ Odoc_extension.t_type_extension ->
+ stringval string_of_class_type_param_list : Types.type_expr list -> stringval string_of_type : Odoc_type.t_type -> stringval string_of_record : Odoc_type.record_field list -> stringval string_of_class_params : Odoc_class.t_class -> stringval string_of_type_extension : Odoc_extension.t_type_extension -> stringval string_of_exception : Odoc_exception.t_exception -> stringval string_of_value : Odoc_value.t_value -> stringval string_of_attribute : Odoc_value.t_attribute -> stringval string_of_method : Odoc_value.t_method -> stringG.generatormethod generate : Odoc_module.t_module list -> unitGenerator.Gclass generator : Odoc_gen.doc_generatorGenerator.generatormethod generate : Odoc_module.t_module list -> unitGenerator.string_genval mutable test_kinds : test_kind listval mutable fmt : Format.formattermethod generate : Odoc_info.Module.t_module list -> unitmethod scan_attribute : Odoc_info.Value.t_attribute -> unitmethod scan_class : Odoc_info.Class.t_class -> unitmethod scan_class_comment : Odoc_info.text -> unitmethod scan_class_elements : Odoc_info.Class.t_class -> unitmethod scan_class_pre : Odoc_info.Class.t_class -> boolmethod scan_class_type : Odoc_info.Class.t_class_type -> unitmethod scan_class_type_comment : Odoc_info.text -> unitmethod scan_class_type_elements : Odoc_info.Class.t_class_type -> unitmethod scan_class_type_pre : Odoc_info.Class.t_class_type -> boolmethod scan_exception : Odoc_info.Exception.t_exception -> unitmethod scan_extension_constructor : Odoc_info.Extension.t_extension_constructor ->
+ unitmethod scan_included_module : Odoc_info.Module.included_module -> unitmethod scan_method : Odoc_info.Value.t_method -> unitmethod scan_module : Odoc_info.Module.t_module -> unitmethod scan_module_comment : Odoc_info.text -> unitmethod scan_module_elements : Odoc_info.Module.t_module -> unitmethod scan_module_list : Odoc_info.Module.t_module list -> unitmethod scan_module_pre : Odoc_info.Module.t_module -> boolmethod scan_module_type : Odoc_info.Module.t_module_type -> unitmethod scan_module_type_comment : Odoc_info.text -> unitmethod scan_module_type_elements : Odoc_info.Module.t_module_type -> unitmethod scan_module_type_pre : Odoc_info.Module.t_module_type -> boolmethod scan_type : Odoc_info.Type.t_type -> unitmethod scan_type_const : Odoc_info.Type.t_type ->
+ Odoc_info.Type.variant_constructor ->
+ unitmethod scan_type_extension : Odoc_info.Extension.t_type_extension -> unitmethod scan_type_extension_constructors : Odoc_info.Extension.t_type_extension ->
+ unitmethod scan_type_extension_pre : Odoc_info.Extension.t_type_extension -> boolmethod scan_type_pre : Odoc_info.Type.t_type -> boolmethod scan_type_recfield : Odoc_info.Type.t_type ->
+ Odoc_info.Type.record_field ->
+ unitmethod scan_value : Odoc_info.Value.t_value -> unitmethod set_test_kinds_from_module : Odoc_info.Module.t_module -> unitOdoc_test.Generatormodule G : Odoc_gen.Baseclass string_gen : object ... endclass generator : object ... endOdoc_testval p :
+ Stdlib.Format.formatter ->
+ ('a, Stdlib.Format.formatter, unit) format ->
+ 'amodule Generator (G : Odoc_gen.Base) : sig ... endGenerator.texival mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval node_tbl : (Odoc_info.Name.t, unit) Hashtbl.tval minus : Odoc_info.text_elementval linebreak : Odoc_info.text_elementval bullet : Odoc_info.text_elementmethod escape : Odoc_info.Name.t -> Odoc_info.Name.tmethod fixedblock : Odoc_info.text_element list -> Odoc_info.text_elementmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_class : out_channel -> Odoc_info.Class.t_class -> unitmethod generate_for_class_type : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : out_channel -> Odoc_info.Module.t_module -> unitmethod generate_for_module_type : out_channel ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_inheritance_info : out_channel ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_texi_header : out_channel ->
+ string ->
+ Odoc_info.Module.t_module list ->
+ unitmethod generate_texi_trailer : out_channel -> unitmethod heading : int -> Odoc_info.text -> stringmethod index : indices -> Odoc_info.Name.t -> Odoc_info.text_elementmethod node : int -> Odoc_info.Name.t -> Odoc_info.text_elementmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod scan_for_index : subparts -> unitmethod scan_for_index_in_class : Odoc_info.Class.class_element -> unitmethod scan_for_index_in_mod : Odoc_info.Module.module_element -> unitmethod string_of_type_args : Odoc_info.Type.constructor_args ->
+ Types.type_expr option ->
+ stringmethod string_of_type_parameters : Odoc_info.Type.t_type -> stringmethod texi_of_Block : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Bold : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Center : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Code : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_CodePre : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Emphasize : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Enum : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Italic : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Left : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Link : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_List : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Newline : Odoc_info.Name.tmethod texi_of_Raw : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Ref : Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.Name.tmethod texi_of_Right : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Subscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Superscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Target : target:string ->
+ code:Odoc_info.Name.t ->
+ Odoc_info.Name.tmethod texi_of_Title : int -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Verbatim : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_attribute : Odoc_info.Value.t_attribute -> stringmethod texi_of_class : Odoc_info.Class.t_class -> stringmethod texi_of_class_element : Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ stringmethod texi_of_class_type : Odoc_info.Class.t_class_type -> stringmethod texi_of_custom_text : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_exception : Odoc_info.Exception.t_exception -> stringmethod texi_of_included_module : Odoc_info.Module.included_module -> stringmethod texi_of_info : Odoc_info.info option -> stringmethod texi_of_method : Odoc_info.Value.t_method -> stringmethod texi_of_module : Odoc_info.Module.t_module -> stringmethod texi_of_module_element : Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ stringmethod texi_of_module_type : Odoc_info.Module.t_module_type -> stringmethod texi_of_text : Odoc_info.text -> stringmethod texi_of_text_element : Odoc_info.text_element -> Odoc_info.Name.tmethod texi_of_type : Odoc_info.Type.t_type -> stringmethod texi_of_type_extension : Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ stringmethod texi_of_value : Odoc_info.Value.t_value -> stringmethod text_el_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_elementmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_desc : Odoc_info.text option -> Odoc_info.text_element listmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_params : Odoc_info.param list -> Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_sees_opt : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listOdoc_texi.Generatorclass texi : object ... endOdoc_texi.Texival subst_strings : (Str.regexp * string) listOdoc_texi.textmethod escape : Odoc_info.Name.t -> Odoc_info.Name.tmethod fixedblock : Odoc_info.text_element list -> Odoc_info.text_elementmethod heading : int -> Odoc_info.text -> stringmethod texi_of_Block : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Bold : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Center : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Code : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_CodePre : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Emphasize : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Enum : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Italic : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Left : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Link : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_List : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Newline : Odoc_info.Name.tmethod texi_of_Raw : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Ref : Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.Name.tmethod texi_of_Right : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Subscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Superscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Target : target:string ->
+ code:Odoc_info.Name.t ->
+ Odoc_info.Name.tmethod texi_of_Title : int -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Verbatim : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_custom_text : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_text : Odoc_info.text -> stringmethod texi_of_text_element : Odoc_info.text_element -> Odoc_info.Name.tOdoc_texival esc_8bits : bool refval info_section : string refval info_entry : string list refval puts_nl : out_channel -> string -> unitval puts : out_channel -> string -> unitval nl : out_channel -> unittype subparts = [ | `Class of Odoc_info.Class.t_class| `Class_type of Odoc_info.Class.t_class_type| `Module of Odoc_info.Module.t_module| `Module_type of Odoc_info.Module.t_module_type ]val nothing : Odoc_info.text_elementval module_subparts :
+ Odoc_info.Module.module_element list ->
+ [> `Class of Odoc_info.Class.t_class
+ | `Class_type of Odoc_info.Class.t_class_type
+ | `Module of Odoc_info.Module.t_module
+ | `Module_type of Odoc_info.Module.t_module_type ]
+ listmodule Texi : sig ... endval titles_and_headings : (int * (string * string)) list refclass text : object ... endmodule Generator : sig ... endmodule type Texi_generator = sig ... endTexi_generator.texival mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listval node_tbl : (Odoc_info.Name.t, unit) Hashtbl.tval minus : Odoc_info.text_elementval linebreak : Odoc_info.text_elementval bullet : Odoc_info.text_elementmethod escape : Odoc_info.Name.t -> Odoc_info.Name.tmethod fixedblock : Odoc_info.text_element list -> Odoc_info.text_elementmethod generate : Odoc_info.Module.t_module list -> unitmethod generate_class_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class ->
+ unitmethod generate_class_type_inheritance_info : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_class : out_channel -> Odoc_info.Class.t_class -> unitmethod generate_for_class_type : out_channel ->
+ Odoc_info.Class.t_class_type ->
+ unitmethod generate_for_module : out_channel -> Odoc_info.Module.t_module -> unitmethod generate_for_module_type : out_channel ->
+ Odoc_info.Module.t_module_type ->
+ unitmethod generate_inheritance_info : out_channel ->
+ Odoc_info.Class.inherited_class list ->
+ unitmethod generate_texi_header : out_channel ->
+ string ->
+ Odoc_info.Module.t_module list ->
+ unitmethod generate_texi_trailer : out_channel -> unitmethod heading : int -> Odoc_info.text -> stringmethod index : indices -> Odoc_info.Name.t -> Odoc_info.text_elementmethod node : int -> Odoc_info.Name.t -> Odoc_info.text_elementmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod scan_for_index : subparts -> unitmethod scan_for_index_in_class : Odoc_info.Class.class_element -> unitmethod scan_for_index_in_mod : Odoc_info.Module.module_element -> unitmethod string_of_type_args : Odoc_info.Type.constructor_args ->
+ Types.type_expr option ->
+ stringmethod string_of_type_parameters : Odoc_info.Type.t_type -> stringmethod texi_of_Block : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Bold : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Center : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Code : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_CodePre : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Emphasize : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Enum : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Italic : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Left : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Link : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_List : Odoc_info.text list -> Odoc_info.Name.tmethod texi_of_Newline : Odoc_info.Name.tmethod texi_of_Raw : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_Ref : Odoc_info.Name.t ->
+ Odoc_info.ref_kind option ->
+ Odoc_info.Name.tmethod texi_of_Right : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Subscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Superscript : Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Target : target:string ->
+ code:Odoc_info.Name.t ->
+ Odoc_info.Name.tmethod texi_of_Title : int -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_Verbatim : Odoc_info.Name.t -> Odoc_info.Name.tmethod texi_of_attribute : Odoc_info.Value.t_attribute -> stringmethod texi_of_class : Odoc_info.Class.t_class -> stringmethod texi_of_class_element : Odoc_info.Name.t ->
+ Odoc_info.Class.class_element ->
+ stringmethod texi_of_class_type : Odoc_info.Class.t_class_type -> stringmethod texi_of_custom_text : string -> Odoc_info.text -> Odoc_info.Name.tmethod texi_of_exception : Odoc_info.Exception.t_exception -> stringmethod texi_of_included_module : Odoc_info.Module.included_module -> stringmethod texi_of_info : Odoc_info.info option -> stringmethod texi_of_method : Odoc_info.Value.t_method -> stringmethod texi_of_module : Odoc_info.Module.t_module -> stringmethod texi_of_module_element : Odoc_info.Name.t ->
+ Odoc_info.Module.module_element ->
+ stringmethod texi_of_module_type : Odoc_info.Module.t_module_type -> stringmethod texi_of_text : Odoc_info.text -> stringmethod texi_of_text_element : Odoc_info.text_element -> Odoc_info.Name.tmethod texi_of_type : Odoc_info.Type.t_type -> stringmethod texi_of_type_extension : Odoc_info.Name.t ->
+ Odoc_info.Extension.t_type_extension ->
+ stringmethod texi_of_value : Odoc_info.Value.t_value -> stringmethod text_el_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_elementmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_desc : Odoc_info.text option -> Odoc_info.text_element listmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_params : Odoc_info.param list -> Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_sees_opt : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listOdoc_texi.Texi_generatorclass texi : object ... endOdoc_text.Texterval text_of_string : string -> Odoc_types.textval string_of_text : Odoc_types.text -> stringOdoc_textmodule Texter : sig ... endOdoc_text_lexerval line_number : int refval char_number : int refval string_buffer : Stdlib.Buffer.tval description : string refval open_brackets : int refval verb_mode : bool refval target_mode : bool refval shortcut_list_mode : bool refval ele_ref_mode : bool refval code_pre_mode : bool refval incr_cpts : Stdlib.Lexing.lexbuf -> unitval main : Stdlib.Lexing.lexbuf -> Odoc_text_parser.tokenval __ocaml_lex_main_rec :
+ Stdlib.Lexing.lexbuf ->
+ int ->
+ Odoc_text_parser.tokenOdoc_text_parsertype token = | END| Title of int * string option| BOLD| EMP| CENTER| LEFT| RIGHT| ITALIC| CUSTOM of string| LIST| ENUM| ITEM| LINK| CODE| END_CODE| CODE_PRE| END_CODE_PRE| VERB| END_VERB| LATEX| Target of string| END_TARGET| LBRACE| ELE_REF| VAL_REF| TYP_REF| EXT_REF| EXC_REF| MOD_REF| MODT_REF| CLA_REF| CLT_REF| ATT_REF| MET_REF| SEC_REF| RECF_REF| CONST_REF| MOD_LIST_REF| INDEX_LIST| SUPERSCRIPT| SUBSCRIPT| BEGIN_SHORTCUT_LIST_ITEM| BEGIN_SHORTCUT_ENUM_ITEM| SHORTCUT_LIST_ITEM| SHORTCUT_ENUM_ITEM| END_SHORTCUT_LIST| BLANK_LINE| EOF| Char of stringval main :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Odoc_types.textval located_element_list :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ (int * int * Odoc_types.text_element) listOdoc_to_text.infoval mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_info : ?block:bool ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listOdoc_to_text.to_textval mutable tag_functions : (string * (Odoc_info.text -> Odoc_info.text)) listmethod normal_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ stringmethod normal_class_type : Odoc_info.Name.t -> Types.class_type -> stringmethod normal_class_type_param_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ stringmethod normal_cstr_args : ?par:bool ->
+ Odoc_info.Name.t ->
+ Odoc_info.Type.constructor_args ->
+ stringmethod normal_module_type : ?code:string ->
+ Odoc_info.Name.t ->
+ Types.module_type ->
+ stringmethod normal_type : Odoc_info.Name.t -> Types.type_expr -> stringmethod normal_type_list : ?par:bool ->
+ Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ stringmethod relative_idents : Odoc_info.Name.t -> string -> stringmethod relative_module_idents : Odoc_info.Name.t -> string -> stringmethod text_of_attribute : Odoc_info.Value.t_attribute ->
+ Odoc_info.text_element listmethod text_of_author_list : string list -> Odoc_info.text_element listmethod text_of_before : (string * Odoc_info.text) list ->
+ Odoc_info.text_element listmethod text_of_class_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_kind ->
+ Odoc_info.text_element listmethod text_of_class_params : Odoc_info.Name.t ->
+ Odoc_info.Class.t_class ->
+ Odoc_types.textmethod text_of_class_type_kind : Odoc_info.Name.t ->
+ Odoc_info.Class.class_type_kind ->
+ Odoc_info.text_element listmethod text_of_class_type_param_expr_list : Odoc_info.Name.t ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_custom : (string * Odoc_info.text) list -> Odoc_info.textmethod text_of_exception : Odoc_info.Exception.t_exception ->
+ Odoc_info.text_element listmethod text_of_info : ?block:bool ->
+ Odoc_info.info option ->
+ Odoc_info.text_element listmethod text_of_method : Odoc_info.Value.t_method -> Odoc_info.text_element listmethod text_of_module_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_kind ->
+ Odoc_info.text_element listmethod text_of_module_parameter_list : (Odoc_info.Module.module_parameter
+ * Odoc_info.text_element list option)
+ list ->
+ Odoc_info.text_element listmethod text_of_module_type : Types.module_type -> Odoc_info.text_element listmethod text_of_module_type_kind : ?with_def_syntax:bool ->
+ Odoc_info.Module.module_type_kind ->
+ Odoc_info.text_element listmethod text_of_parameter_description : Odoc_info.Parameter.parameter ->
+ Odoc_info.textmethod text_of_parameter_list : Odoc_info.Name.t ->
+ Odoc_info.Parameter.parameter list ->
+ Odoc_info.text_element listmethod text_of_raised_exceptions : Odoc_info.raised_exception list ->
+ Odoc_info.text_element listmethod text_of_return_opt : Odoc_info.text option ->
+ Odoc_info.text_element listmethod text_of_see : Odoc_info.see -> Odoc_info.textmethod text_of_sees : Odoc_info.see list -> Odoc_info.text_element listmethod text_of_short_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_since_opt : string option -> Odoc_info.text_element listmethod text_of_type_expr : Odoc_info.Name.t ->
+ Types.type_expr ->
+ Odoc_info.text_element listmethod text_of_type_expr_list : Odoc_info.Name.t ->
+ string ->
+ Types.type_expr list ->
+ Odoc_info.text_element listmethod text_of_value : Odoc_info.Value.t_value -> Odoc_info.text_element listmethod text_of_version_opt : string option -> Odoc_info.text_element listOdoc_to_textOdoc_typemodule Name = Odoc_nametype record_field = {rf_name : string;rf_mutable : bool;rf_type : Types.type_expr;mutable rf_text : Odoc_types.info option;}type variant_constructor = {vc_name : string;vc_args : constructor_args;vc_ret : Types.type_expr option;mutable vc_text : Odoc_types.info option;}type type_kind = | Type_abstract| Type_variant of variant_constructor list| Type_record of record_field list| Type_opentype object_field = {of_name : string;of_type : Types.type_expr;mutable of_text : Odoc_types.info option;}type t_type = {ty_name : Name.t;mutable ty_info : Odoc_types.info option;ty_parameters : (Types.type_expr * bool * bool) list;ty_kind : type_kind;ty_private : private_flag;ty_manifest : type_manifest option;mutable ty_loc : Odoc_types.location;mutable ty_code : string option;}Odoc_typestype ref_kind = | RK_module| RK_module_type| RK_class| RK_class_type| RK_value| RK_type| RK_extension| RK_exception| RK_attribute| RK_method| RK_section of text| RK_recfield| RK_constand text_element = | Raw of string| Code of string| CodePre of string| Verbatim of string| Bold of text| Italic of text| Emphasize of text| Center of text| Left of text| Right of text| List of text list| Enum of text list| Newline| Block of text| Title of int * string option * text| Latex of string| Link of string * text| Ref of string * ref_kind option * text option| Superscript of text| Subscript of text| Module_list of string list| Index_list| Custom of string * text| Target of string * stringand text = text_element listtype param = string * texttype raised_exception = string * textval dummy_info : infoval dummy_loc : locationval all_merge_options : merge_option listval magic : magicval make_dump : 'a -> 'a dumpval open_dump : 'a dump -> 'aOdoc_valuemodule Name = Odoc_nametype t_value = {val_name : Name.t;mutable val_info : Odoc_types.info option;val_type : Types.type_expr;val_recursive : bool;mutable val_parameters : Odoc_parameter.parameter list;mutable val_code : string option;mutable val_loc : Odoc_types.location;}val value_parameter_text_by_name : t_value -> string -> Odoc_types.text optionval update_value_parameters_text : t_value -> unitval parameter_list_from_arrows :
+ Types.type_expr ->
+ (Asttypes.arg_label * Types.type_expr) listval dummy_parameter_list : Types.type_expr -> Odoc_parameter.param_info listval is_function : t_value -> boolOpcodesOprintval out_ident : (Stdlib.Format.formatter -> Outcometree.out_ident -> unit) refval out_value : (Stdlib.Format.formatter -> Outcometree.out_value -> unit) refval out_label :
+ (Stdlib.Format.formatter ->
+ (string * bool * Outcometree.out_type) ->
+ unit)
+ refval out_type : (Stdlib.Format.formatter -> Outcometree.out_type -> unit) refval out_constr :
+ (Stdlib.Format.formatter -> Outcometree.out_constructor -> unit) refval out_class_type :
+ (Stdlib.Format.formatter -> Outcometree.out_class_type -> unit) refval out_module_type :
+ (Stdlib.Format.formatter -> Outcometree.out_module_type -> unit) refval out_sig_item :
+ (Stdlib.Format.formatter -> Outcometree.out_sig_item -> unit) refval out_signature :
+ (Stdlib.Format.formatter -> Outcometree.out_sig_item list -> unit) refval out_functor_parameters :
+ (Stdlib.Format.formatter ->
+ (string option * Outcometree.out_module_type) option list ->
+ unit)
+ refval out_type_extension :
+ (Stdlib.Format.formatter -> Outcometree.out_type_extension -> unit) refval out_phrase :
+ (Stdlib.Format.formatter -> Outcometree.out_phrase -> unit) refOptcompileNative compilation for .ml and .mli files.
val implementation :
+ backend:(module Backend_intf.S) ->
+ start_from:Clflags.Compiler_pass.t ->
+ source_file:string ->
+ output_prefix:string ->
+ unit*
val clambda :
+ Compile_common.info ->
+ (module Backend_intf.S) ->
+ Typedtree.implementation ->
+ unitclambda info typed applies the regular compilation pipeline to the given typechecked implementation and outputs the resulting files.
val flambda :
+ Compile_common.info ->
+ (module Backend_intf.S) ->
+ Typedtree.implementation ->
+ unitflambda info backend typed applies the Flambda compilation pipeline to the given typechecked implementation and outputs the resulting files.
Opterrorsval report_error : Stdlib.Format.formatter -> exn -> unitOptmainOptmaindriverval main : string array -> Stdlib.Format.formatter -> intOutcometreeAn out_name is a string representation of an identifier which can be rewritten on the fly to avoid name collisions
type out_value = | Oval_array of out_value list| Oval_char of char| Oval_constr of out_ident * out_value list| Oval_ellipsis| Oval_float of float| Oval_int of int| Oval_int32 of int32| Oval_int64 of int64| Oval_nativeint of nativeint| Oval_list of out_value list| Oval_printer of Stdlib.Format.formatter -> unit| Oval_record of (out_ident * out_value) list| Oval_string of string * int * out_string| Oval_stuff of string| Oval_tuple of out_value list| Oval_variant of string * out_value optiontype out_type_param = string * (Asttypes.variance * Asttypes.injectivity)type out_type = | Otyp_abstract| Otyp_open| Otyp_alias of out_type * string| Otyp_arrow of string * out_type * out_type| Otyp_class of bool * out_ident * out_type list| Otyp_constr of out_ident * out_type list| Otyp_manifest of out_type * out_type| Otyp_object of (string * out_type) list * bool option| Otyp_record of (string * bool * out_type) list| Otyp_stuff of string| Otyp_sum of out_constructor list| Otyp_tuple of out_type list| Otyp_var of bool * string| Otyp_variant of bool * out_variant * bool * string list option| Otyp_poly of string list * out_type| Otyp_module of out_ident * (string * out_type) list| Otyp_attribute of out_type * out_attributetype out_class_type = | Octy_constr of out_ident * out_type list| Octy_arrow of string * out_type * out_class_type| Octy_signature of out_type option * out_class_sig_item listtype out_module_type = | Omty_abstract| Omty_functor of (string option * out_module_type) option * out_module_type| Omty_ident of out_ident| Omty_signature of out_sig_item list| Omty_alias of out_identand out_sig_item = | Osig_class of bool
+ * string
+ * out_type_param list
+ * out_class_type
+ * out_rec_status| Osig_class_type of bool
+ * string
+ * out_type_param list
+ * out_class_type
+ * out_rec_status| Osig_typext of out_extension_constructor * out_ext_status| Osig_modtype of string * out_module_type| Osig_module of string * out_module_type * out_rec_status| Osig_type of out_type_decl * out_rec_status| Osig_value of out_val_decl| Osig_ellipsisand out_type_decl = {otype_name : string;otype_params : out_type_param list;otype_type : out_type;otype_private : Asttypes.private_flag;otype_immediate : Type_immediacy.t;otype_unboxed : bool;otype_cstrs : (out_type * out_type) list;}and out_extension_constructor = {oext_name : string;oext_type_name : string;oext_type_params : string list;oext_args : out_type list;oext_ret_type : out_type option;oext_private : Asttypes.private_flag;}and out_type_extension = {otyext_name : string;otyext_params : string list;otyext_constructors : out_constructor list;otyext_private : Asttypes.private_flag;}and out_val_decl = {oval_name : string;oval_type : out_type;oval_prims : string list;oval_attributes : out_attribute list;}type out_phrase = | Ophr_eval of out_value * out_type| Ophr_signature of (out_sig_item * out_value option) list| Ophr_exception of exn * out_valueParameter.Listval vars : t list -> Variable.t listextract variables from a list of parameters, preserving the order
Parameter.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitParameter.Setinclude Identifiable.Set with module T := Tinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringval vars : parameter list -> Variable.Set.tParameter.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitParameter.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tParameterParameter.t carries a unique Variable.t used as function parameter. It can also carry annotations about the usage of the variable.
type parameter = tval wrap : Variable.t -> tMake a parameter from a variable with default attributes
val var : t -> Variable.tval rename : ?current_compilation_unit:Compilation_unit.t -> t -> tRename the inner variable of the parameter
val map_var : (Variable.t -> Variable.t) -> t -> tmodule T : Identifiable.Thing with type t = tmodule Set : sig ... endinclude Identifiable.S with type t := t and module T := T and module Set := Setinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tmodule List : sig ... endCompat._val equal :
+ Types.constructor_description ->
+ Types.constructor_description ->
+ boolParmatch.CompatExported compatibility functor, abstracted over constructor equality
module _ : sig ... endval compat : Typedtree.pattern -> Typedtree.pattern -> boolval compats : Typedtree.pattern list -> Typedtree.pattern list -> boolParmatchDetection of partial matches and unused match cases.
val const_compare : Asttypes.constant -> Asttypes.constant -> intconst_compare c1 c2 compares the actual values represented by c1 and c2, while simply using Stdlib.compare would compare the representations.
cf. MPR#5758
val le_pat : Typedtree.pattern -> Typedtree.pattern -> boolle_pat p q means: forall V, V matches q implies V matches p
val le_pats : Typedtree.pattern list -> Typedtree.pattern list -> boolle_pats (p1 .. pm) (q1 .. qn) means: forall i <= m, le_pat pi qi
Exported compatibility functor, abstracted over constructor equality
val lub : Typedtree.pattern -> Typedtree.pattern -> Typedtree.patternlub p q is a pattern that matches all values matched by p and q. May raise Empty, when p and q are not compatible.
val lubs :
+ Typedtree.pattern list ->
+ Typedtree.pattern list ->
+ Typedtree.pattern listlubs [p1; ...; pn] [q1; ...; qk], where n < k, is [lub p1 q1; ...; lub pk qk].
val set_args :
+ Typedtree.pattern ->
+ Typedtree.pattern list ->
+ Typedtree.pattern listThose two functions recombine one pattern and its arguments: For instance: (_,_)::p1::p2::rem -> (p1, p2)::rem The second one will replace mutable arguments by '_'
val set_args_erase_mutable :
+ Typedtree.pattern ->
+ Typedtree.pattern list ->
+ Typedtree.pattern listval pat_of_constr :
+ Typedtree.pattern ->
+ Types.constructor_description ->
+ Typedtree.patternval complete_constrs :
+ Types.constructor_description Typedtree.pattern_data ->
+ Types.constructor_description list ->
+ Types.constructor_description listppat_of_type builds an untyped pattern from its expected type, for explosion of wildcard patterns in Typecore.type_pat.
There are four interesting cases:
PT_empty)PT_any)PE_single)PE_gadt_cases).type ppat_of_type = | PT_empty| PT_any| PT_pattern of pat_explosion
+ * Parsetree.pattern
+ * (string, Types.constructor_description) Stdlib.Hashtbl.t
+ * (string, Types.label_description) Stdlib.Hashtbl.tval ppat_of_type : Env.t -> Types.type_expr -> ppat_of_typeval pressure_variants : Env.t -> Typedtree.pattern list -> unitval pressure_variants_in_computation_pattern :
+ Env.t ->
+ Typedtree.computation Typedtree.general_pattern list ->
+ unitval check_partial :
+ ((string, Types.constructor_description) Stdlib.Hashtbl.t ->
+ (string, Types.label_description) Stdlib.Hashtbl.t ->
+ Parsetree.pattern ->
+ Typedtree.pattern option) ->
+ Location.t ->
+ Typedtree.value Typedtree.case list ->
+ Typedtree.partialcheck_partial pred loc caselist and check_unused refute pred caselist are called with a function pred which will be given counter-example candidates: they may be partially ill-typed, and have to be type-checked to extract a valid counter-example. pred returns a valid counter-example or None. refute indicates that check_unused was called on a refutation clause.
val check_unused :
+ (bool ->
+ (string, Types.constructor_description) Stdlib.Hashtbl.t ->
+ (string, Types.label_description) Stdlib.Hashtbl.t ->
+ Parsetree.pattern ->
+ Typedtree.pattern option) ->
+ Typedtree.value Typedtree.case list ->
+ unitval irrefutable : Typedtree.pattern -> boolval inactive : partial:Typedtree.partial -> Typedtree.pattern -> boolAn inactive pattern is a pattern, matching against which can be duplicated, erased or delayed without change in observable behavior of the program. Patterns containing (lazy _) subpatterns or reads of mutable fields are active.
val check_ambiguous_bindings : Typedtree.value Typedtree.case list -> unitval some_private_tag : Asttypes.labelParseEntry points in the parser
Warning: this module is unstable and part of compiler-libs.
val implementation : Stdlib.Lexing.lexbuf -> Parsetree.structureval interface : Stdlib.Lexing.lexbuf -> Parsetree.signatureval toplevel_phrase : Stdlib.Lexing.lexbuf -> Parsetree.toplevel_phraseval use_file : Stdlib.Lexing.lexbuf -> Parsetree.toplevel_phrase listval core_type : Stdlib.Lexing.lexbuf -> Parsetree.core_typeval expression : Stdlib.Lexing.lexbuf -> Parsetree.expressionval pattern : Stdlib.Lexing.lexbuf -> Parsetree.patternval module_type : Stdlib.Lexing.lexbuf -> Parsetree.module_typeval module_expr : Stdlib.Lexing.lexbuf -> Parsetree.module_exprThe functions below can be used to parse Longident safely.
val longident : Stdlib.Lexing.lexbuf -> Longident.tThe function longident is guaranteed to parse all subclasses of Longident.t used in OCaml: values, constructors, simple or extended module paths, and types or module types.
However, this function accepts inputs which are not accepted by the compiler, because they combine functor applications and infix operators. In valid OCaml syntax, only value-level identifiers may end with infix operators Foo.( + ). Moreover, in value-level identifiers the module path Foo must be simple (M.N rather than F(X)): functor applications may only appear in type-level identifiers. As a consequence, a path such as F(X).( + ) is not a valid OCaml identifier; but it is accepted by this function.
The next functions are specialized to a subclass of Longident.t
val val_ident : Stdlib.Lexing.lexbuf -> Longident.tThis function parses a syntactically valid path for a value. For instance, x, M.x, and (+.) are valid. Contrarily, M.A, F(X).x, and true are rejected.
Longident for OCaml's value cannot contain functor application. The last component of the Longident.t is not capitalized, but can be an operator A.Path.To.(.%.%.(;..)<-)
val constr_ident : Stdlib.Lexing.lexbuf -> Longident.tThis function parses a syntactically valid path for a variant constructor. For instance, A, M.A and M.(::) are valid, but both M.a and F(X).A are rejected.
Longident for OCaml's variant constructors cannot contain functor application. The last component of the Longident.t is capitalized, or it may be one the special constructors: true,false,(),[],(::). Among those special constructors, only (::) can be prefixed by a module path (A.B.C.(::)).
val simple_module_path : Stdlib.Lexing.lexbuf -> Longident.tThis function parses a syntactically valid path for a module. For instance, A, and M.A are valid, but both M.a and F(X).A are rejected.
Longident for OCaml's module cannot contain functor application. The last component of the Longident.t is capitalized.
val extended_module_path : Stdlib.Lexing.lexbuf -> Longident.tThis function parse syntactically valid path for an extended module. For instance, A.B and F(A).B are valid. Contrarily, (.%()) or [] are both rejected.
The last component of the Longident.t is capitalized.
val type_ident : Stdlib.Lexing.lexbuf -> Longident.tThis function parse syntactically valid path for a type or a module type. For instance, A, t, M.t and F(X).t are valid. Contrarily, (.%()) or [] are both rejected.
In path for type and module types, only operators and special constructors are rejected.
Parser.Incrementalval use_file :
+ Stdlib.Lexing.position ->
+ Parsetree.toplevel_phrase list MenhirInterpreter.checkpointval toplevel_phrase :
+ Stdlib.Lexing.position ->
+ Parsetree.toplevel_phrase MenhirInterpreter.checkpointval parse_val_longident :
+ Stdlib.Lexing.position ->
+ Longident.t MenhirInterpreter.checkpointval parse_pattern :
+ Stdlib.Lexing.position ->
+ Parsetree.pattern MenhirInterpreter.checkpointval parse_mty_longident :
+ Stdlib.Lexing.position ->
+ Longident.t MenhirInterpreter.checkpointval parse_module_type :
+ Stdlib.Lexing.position ->
+ Parsetree.module_type MenhirInterpreter.checkpointval parse_module_expr :
+ Stdlib.Lexing.position ->
+ Parsetree.module_expr MenhirInterpreter.checkpointval parse_mod_longident :
+ Stdlib.Lexing.position ->
+ Longident.t MenhirInterpreter.checkpointval parse_mod_ext_longident :
+ Stdlib.Lexing.position ->
+ Longident.t MenhirInterpreter.checkpointval parse_expression :
+ Stdlib.Lexing.position ->
+ Parsetree.expression MenhirInterpreter.checkpointval parse_core_type :
+ Stdlib.Lexing.position ->
+ Parsetree.core_type MenhirInterpreter.checkpointval parse_constr_longident :
+ Stdlib.Lexing.position ->
+ Longident.t MenhirInterpreter.checkpointval parse_any_longident :
+ Stdlib.Lexing.position ->
+ Longident.t MenhirInterpreter.checkpointval interface :
+ Stdlib.Lexing.position ->
+ Parsetree.signature MenhirInterpreter.checkpointval implementation :
+ Stdlib.Lexing.position ->
+ Parsetree.structure MenhirInterpreter.checkpointParser.MenhirInterpreterinclude CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE
+ with type token = tokentype token = tokenval offer :
+ 'a checkpoint ->
+ (token
+ * CamlinternalMenhirLib.IncrementalEngine.position
+ * CamlinternalMenhirLib.IncrementalEngine.position) ->
+ 'a checkpointval resume : ?strategy:strategy -> 'a checkpoint -> 'a checkpointtype supplier =
+ unit ->
+ token
+ * CamlinternalMenhirLib.IncrementalEngine.position
+ * CamlinternalMenhirLib.IncrementalEngine.positionval lexer_lexbuf_to_supplier :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ supplierval loop : ?strategy:strategy -> supplier -> 'a checkpoint -> 'aval loop_handle :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval loop_handle_undo :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval shifts : 'a checkpoint -> 'a env optionval acceptable :
+ 'a checkpoint ->
+ token ->
+ CamlinternalMenhirLib.IncrementalEngine.position ->
+ boolval number : _ lr1state -> intval production_index : production -> intval find_production : int -> productiontype element = | Element : 'a lr1state
+ * 'a
+ * CamlinternalMenhirLib.IncrementalEngine.position
+ * CamlinternalMenhirLib.IncrementalEngine.position -> elementtype stack = element CamlinternalMenhirLib.General.streamval current_state_number : 'a env -> intval positions :
+ 'a env ->
+ CamlinternalMenhirLib.IncrementalEngine.position
+ * CamlinternalMenhirLib.IncrementalEngine.positionval env_has_default_reduction : 'a env -> boolval state_has_default_reduction : _ lr1state -> boolval force_reduction : production -> 'a env -> 'a envval input_needed : 'a env -> 'a checkpointParsertype token = | WITH| WHILE| WHEN| VIRTUAL| VAL| UNDERSCORE| UIDENT of string| TYPE| TRY| TRUE| TO| TILDE| THEN| STRUCT| STRING of string * Location.t * string option| STAR| SIG| SEMISEMI| SEMI| RPAREN| REC| RBRACKET| RBRACE| QUOTED_STRING_ITEM of string * Location.t * string * Location.t * string option| QUOTED_STRING_EXPR of string * Location.t * string * Location.t * string option| QUOTE| QUESTION| PRIVATE| PREFIXOP of string| PLUSEQ| PLUSDOT| PLUS| PERCENT| OR| OPTLABEL of string| OPEN| OF| OBJECT| NONREC| NEW| MUTABLE| MODULE| MINUSGREATER| MINUSDOT| MINUS| METHOD| MATCH| LPAREN| LIDENT of string| LETOP of string| LET| LESSMINUS| LESS| LBRACKETPERCENTPERCENT| LBRACKETPERCENT| LBRACKETLESS| LBRACKETGREATER| LBRACKETBAR| LBRACKETATATAT| LBRACKETATAT| LBRACKETAT| LBRACKET| LBRACELESS| LBRACE| LAZY| LABEL of string| INT of string * char option| INITIALIZER| INHERIT| INFIXOP4 of string| INFIXOP3 of string| INFIXOP2 of string| INFIXOP1 of string| INFIXOP0 of string| INCLUDE| IN| IF| HASHOP of string| HASH| GREATERRBRACKET| GREATERRBRACE| GREATER| FUNCTOR| FUNCTION| FUN| FOR| FLOAT of string * char option| FALSE| EXTERNAL| EXCEPTION| EQUAL| EOL| EOF| END| ELSE| DOWNTO| DOTOP of string| DOTDOT| DOT| DONE| DOCSTRING of Docstrings.docstring| DO| CONSTRAINT| COMMENT of string * Location.t| COMMA| COLONGREATER| COLONEQUAL| COLONCOLON| COLON| CLASS| CHAR of char| BEGIN| BARRBRACKET| BARBAR| BAR| BANG| BACKQUOTE| ASSERT| AS| ANDOP of string| AND| AMPERSAND| AMPERAMPERval use_file :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.toplevel_phrase listval toplevel_phrase :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.toplevel_phraseval parse_val_longident :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Longident.tval parse_pattern :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.patternval parse_mty_longident :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Longident.tval parse_module_type :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.module_typeval parse_module_expr :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.module_exprval parse_mod_longident :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Longident.tval parse_mod_ext_longident :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Longident.tval parse_expression :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.expressionval parse_core_type :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.core_typeval parse_constr_longident :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Longident.tval parse_any_longident :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Longident.tval interface :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.signatureval implementation :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.structuremodule MenhirInterpreter : sig ... endmodule Incremental : sig ... endParsetreeAbstract syntax tree produced by parsing
Warning: this module is unstable and part of compiler-libs.
type constant = | Pconst_integer of string * char optionInteger constants such as 3 3l 3L 3n.
Suffixes [g-z][G-Z] are accepted by the parser. Suffixes except 'l', 'L' and 'n' are rejected by the typechecker
| Pconst_char of charCharacter such as 'c'.
| Pconst_string of string * Location.t * string optionConstant string such as "constant" or {delim|other constant|delim}.
The location span the content of the string, without the delimiters.
*)| Pconst_float of string * char optionFloat constant such as 3.4, 2e5 or 1.4e-4.
Suffixes g-zG-Z are accepted by the parser. Suffixes are rejected by the typechecker.
type location_stack = Location.t listAttributes such as [\@id ARG] and [\@\@id ARG].
Metadata containers passed around within the AST. The compiler ignores unknown attributes.
and extension = string Asttypes.loc * payloadExtension points such as [%id ARG] and [%%id ARG].
Sub-language placeholder -- rejected by the typechecker.
and attributes = attribute listand payload = | PStr of structure| PSig of signature: SIG in an attribute or an extension point
| PTyp of core_type: T in an attribute or an extension point
| PPat of pattern * expression option? P or ? P when E, in an attribute or an extension point
and core_type = {ptyp_desc : core_type_desc;ptyp_loc : Location.t;ptyp_loc_stack : location_stack;ptyp_attributes : attributes;... [\@id1] [\@id2]
}and core_type_desc = | Ptyp_any_
| Ptyp_var of stringA type variable such as 'a
| Ptyp_arrow of Asttypes.arg_label * core_type * core_type| Ptyp_tuple of core_type listPtyp_tuple([T1 ; ... ; Tn]) represents a product type T1 * ... * Tn.
Invariant: n >= 2.
| Ptyp_constr of Longident.t Asttypes.loc * core_type listPtyp_constr(lident, l) represents:
tconstr when l=[],T tconstr when l=[T],(T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].| Ptyp_object of object_field list * Asttypes.closed_flag| Ptyp_class of Longident.t Asttypes.loc * core_type listPtyp_class(tconstr, l) represents:
#tconstr when l=[],T #tconstr when l=[T],(T1, ..., Tn) #tconstr when l=[T1 ; ... ; Tn].| Ptyp_alias of core_type * stringT as 'a.
| Ptyp_variant of row_field list
+ * Asttypes.closed_flag
+ * Asttypes.label list option| Ptyp_poly of string Asttypes.loc list * core_type'a1 ... 'an. T
Can only appear in the following context:
As the core_type of a Ppat_constraint node corresponding to a constraint on a let-binding:
let x : 'a1 ... 'an. T = e ...Cfk_virtual for methods (not values).core_type of a Pctf_method node.pld_type field of a label_declaration.core_type of a Ptyp_object node.pval_type field of a value_description.| Ptyp_package of package_type(module S).
| Ptyp_extension of extension[%id].
and package_type =
+ Longident.t Asttypes.loc * (Longident.t Asttypes.loc * core_type) listAs package_type typed values:
(S, []) represents (module S),(S, [(t1, T1) ; ... ; (tn, Tn)]) represents (module S with type t1 = T1 and ... and tn = Tn).and row_field_desc = | Rtag of Asttypes.label Asttypes.loc * bool * core_type listRtag(`A, b, l) represents:
`A when b is true and l is [],`A of T when b is false and l is [T],`A of T1 & .. & Tn when b is false and l is [T1;...Tn],`A of & T1 & .. & Tn when b is true and l is [T1;...Tn].bool field is true if the tag contains a constant (empty) constructor.& occurs when several types are used for the same constructor (see 4.2 in the manual)| Rinherit of core_type[ | t ]
and pattern = {ppat_desc : pattern_desc;ppat_loc : Location.t;ppat_loc_stack : location_stack;ppat_attributes : attributes;... [\@id1] [\@id2]
}and pattern_desc = | Ppat_anyThe pattern _.
| Ppat_var of string Asttypes.locA variable pattern such as x
| Ppat_alias of pattern * string Asttypes.locAn alias pattern such as P as 'a
| Ppat_constant of constantPatterns such as 1, 'a', "true", 1.0, 1l, 1L, 1n
| Ppat_interval of constant * constantPatterns such as 'a'..'z'.
Other forms of interval are recognized by the parser but rejected by the type-checker.
*)| Ppat_tuple of pattern listPatterns (P1, ..., Pn).
Invariant: n >= 2
| Ppat_construct of Longident.t Asttypes.loc
+ * (string Asttypes.loc list * pattern) optionPpat_construct(C, args) represents:
C when args is None,C P when args is Some ([], P)C (P1, ..., Pn) when args is Some ([], Ppat_tuple [P1; ...; Pn])C (type a b) P when args is Some ([a; b], P)| Ppat_variant of Asttypes.label * pattern optionPpat_variant(`A, pat) represents:
`A when pat is None,`A P when pat is Some P| Ppat_record of (Longident.t Asttypes.loc * pattern) list * Asttypes.closed_flag| Ppat_array of pattern listPattern [| P1; ...; Pn |]
| Ppat_or of pattern * patternPattern P1 | P2
| Ppat_constraint of pattern * core_typePattern (P : T)
| Ppat_type of Longident.t Asttypes.locPattern #tconst
| Ppat_lazy of patternPattern lazy P
| Ppat_unpack of string option Asttypes.locPpat_unpack(s) represents:
(module P) when s is Some "P"(module _) when s is NoneNote: (module P : S) is represented as Ppat_constraint(Ppat_unpack(Some "P"), Ptyp_package S)
| Ppat_exception of patternPattern exception P
| Ppat_extension of extensionPattern [%id]
| Ppat_open of Longident.t Asttypes.loc * patternPattern M.(P)
and expression = {pexp_desc : expression_desc;pexp_loc : Location.t;pexp_loc_stack : location_stack;pexp_attributes : attributes;... [\@id1] [\@id2]
}and expression_desc = | Pexp_ident of Longident.t Asttypes.locIdentifiers such as x and M.x
| Pexp_constant of constantExpressions constant such as 1, 'a', "true", 1.0, 1l, 1L, 1n
| Pexp_let of Asttypes.rec_flag * value_binding list * expressionPexp_let(flag, [(P1,E1) ; ... ; (Pn,En)], E) represents:
let P1 = E1 and ... and Pn = EN in E when flag is Nonrecursive,let rec P1 = E1 and ... and Pn = EN in E when flag is Recursive.| Pexp_function of case listfunction P1 -> E1 | ... | Pn -> En
| Pexp_fun of Asttypes.arg_label * expression option * pattern * expressionPexp_fun(lbl, exp0, P, E1) represents:
fun P -> E1 when lbl is Nolabel and exp0 is Nonefun ~l:P -> E1 when lbl is Labelled l and exp0 is Nonefun ?l:P -> E1 when lbl is Optional l and exp0 is Nonefun ?l:(P = E0) -> E1 when lbl is Optional l and exp0 is Some E0Notes:
E0 is provided, only Optional is allowed.fun P1 P2 .. Pn -> E1 is represented as nested Pexp_fun.let f P = E is represented using Pexp_fun.| Pexp_apply of expression * (Asttypes.arg_label * expression) list| Pexp_match of expression * case listmatch E0 with P1 -> E1 | ... | Pn -> En
| Pexp_try of expression * case listtry E0 with P1 -> E1 | ... | Pn -> En
| Pexp_tuple of expression listExpressions (E1, ..., En)
Invariant: n >= 2
| Pexp_construct of Longident.t Asttypes.loc * expression optionPexp_construct(C, exp) represents:
C when exp is None,C E when exp is Some E,C (E1, ..., En) when exp is Some (Pexp_tuple[E1;...;En])| Pexp_variant of Asttypes.label * expression optionPexp_variant(`A, exp) represents
`A when exp is None`A E when exp is Some E| Pexp_record of (Longident.t Asttypes.loc * expression) list * expression optionPexp_record([(l1,P1) ; ... ; (ln,Pn)], exp0) represents
{ l1=P1; ...; ln=Pn } when exp0 is None{ E0 with l1=P1; ...; ln=Pn } when exp0 is Some E0Invariant: n > 0
| Pexp_field of expression * Longident.t Asttypes.locE.l
| Pexp_setfield of expression * Longident.t Asttypes.loc * expressionE1.l <- E2
| Pexp_array of expression list[| E1; ...; En |]
| Pexp_ifthenelse of expression * expression * expression optionif E1 then E2 else E3
| Pexp_sequence of expression * expressionE1; E2
| Pexp_while of expression * expressionwhile E1 do E2 done
| Pexp_for of pattern
+ * expression
+ * expression
+ * Asttypes.direction_flag
+ * expression| Pexp_constraint of expression * core_type(E : T)
| Pexp_coerce of expression * core_type option * core_typePexp_coerce(E, from, T) represents
(E :> T) when from is None,(E : T0 :> T) when from is Some T0.| Pexp_send of expression * Asttypes.label Asttypes.locE # m
| Pexp_new of Longident.t Asttypes.locnew M.c
| Pexp_setinstvar of Asttypes.label Asttypes.loc * expressionx <- 2
| Pexp_override of (Asttypes.label Asttypes.loc * expression) list{< x1 = E1; ...; xn = En >}
| Pexp_letmodule of string option Asttypes.loc * module_expr * expressionlet module M = ME in E
| Pexp_letexception of extension_constructor * expressionlet exception C in E
| Pexp_assert of expressionassert E.
Note: assert false is treated in a special way by the type-checker.
| Pexp_lazy of expressionlazy E
| Pexp_poly of expression * core_type optionUsed for method bodies.
Can only be used as the expression under Cfk_concrete for methods (not values).
| Pexp_object of class_structureobject ... end
| Pexp_newtype of string Asttypes.loc * expressionfun (type t) -> E
| Pexp_pack of module_expr(module ME).
(module ME : S) is represented as Pexp_constraint(Pexp_pack ME, Ptyp_package S)
| Pexp_open of open_declaration * expressionM.(E)let open M in Elet open! M in E| Pexp_letop of letoplet* P = E0 in E1let* P0 = E00 and* P1 = E01 in E1| Pexp_extension of extension[%id]
| Pexp_unreachable.
Values of type case represents (P -> E) or (P when E0 -> E)
and binding_op = {pbop_op : string Asttypes.loc;pbop_pat : pattern;pbop_exp : expression;pbop_loc : Location.t;}and value_description = {pval_name : string Asttypes.loc;pval_type : core_type;pval_prim : string list;pval_attributes : attributes;... [\@\@id1] [\@\@id2]
pval_loc : Location.t;}Values of type value_description represents:
and type_declaration = {ptype_name : string Asttypes.loc;ptype_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;('a1,...'an) t
ptype_cstrs : (core_type * core_type * Location.t) list;... constraint T1=T1' ... constraint Tn=Tn'
ptype_kind : type_kind;ptype_private : Asttypes.private_flag;for = private ...
ptype_manifest : core_type option;represents = T
ptype_attributes : attributes;... [\@\@id1] [\@\@id2]
ptype_loc : Location.t;}Here are type declarations and their representation, for various ptype_kind and ptype_manifest values:
type t when type_kind is Ptype_abstract, and manifest is None,type t = T0 when type_kind is Ptype_abstract, and manifest is Some T0,type t = C of T | ... when type_kind is Ptype_variant, and manifest is None,type t = T0 = C of T | ... when type_kind is Ptype_variant, and manifest is Some T0,type t = {l: T; ...} when type_kind is Ptype_record, and manifest is None,type t = T0 = {l : T; ...} when type_kind is Ptype_record, and manifest is Some T0,type t = .. when type_kind is Ptype_open, and manifest is None.and type_kind = | Ptype_abstract| Ptype_variant of constructor_declaration list| Ptype_record of label_declaration listInvariant: non-empty list
*)| Ptype_openand label_declaration = {pld_name : string Asttypes.loc;pld_mutable : Asttypes.mutable_flag;pld_type : core_type;pld_loc : Location.t;pld_attributes : attributes;l : T [\@id1] [\@id2]
}{ ...; l: T; ... } when pld_mutable is Immutable,{ ...; mutable l: T; ... } when pld_mutable is Mutable.Note: T can be a Ptyp_poly.
and constructor_declaration = {pcd_name : string Asttypes.loc;pcd_vars : string Asttypes.loc list;pcd_args : constructor_arguments;pcd_res : core_type option;pcd_loc : Location.t;pcd_attributes : attributes;C of ... [\@id1] [\@id2]
}and constructor_arguments = | Pcstr_tuple of core_type list| Pcstr_record of label_declaration listValues of type constructor_declaration represents the constructor arguments of:
C of T1 * ... * Tn when res = None, and args = Pcstr_tuple [T1; ... ; Tn],C: T0 when res = Some T0, and args = Pcstr_tuple [],C: T1 * ... * Tn -> T0 when res = Some T0, and args = Pcstr_tuple [T1; ... ; Tn],C of {...} when res = None, and args = Pcstr_record [...],C: {...} -> T0 when res = Some T0, and args = Pcstr_record [...].and type_extension = {ptyext_path : Longident.t Asttypes.loc;ptyext_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;ptyext_constructors : extension_constructor list;ptyext_private : Asttypes.private_flag;ptyext_loc : Location.t;ptyext_attributes : attributes;... \@\@id1 \@\@id2
}Definition of new extensions constructors for the extensive sum type t (type t += ...).
and extension_constructor = {pext_name : string Asttypes.loc;pext_kind : extension_constructor_kind;pext_loc : Location.t;pext_attributes : attributes;C of ... [\@id1] [\@id2]
}and type_exception = {ptyexn_constructor : extension_constructor;ptyexn_loc : Location.t;ptyexn_attributes : attributes;... [\@\@id1] [\@\@id2]
}Definition of a new exception (exception E).
and extension_constructor_kind = | Pext_decl of string Asttypes.loc list
+ * constructor_arguments
+ * core_type optionPext_decl(existentials, c_args, t_opt) describes a new extension constructor. It can be:
C of T1 * ... * Tn when:
existentials is [],c_args is [T1; ...; Tn],t_opt is NoneC: T0 when
existentials is [],c_args is [],t_opt is Some T0.C: T1 * ... * Tn -> T0 when
existentials is [],c_args is [T1; ...; Tn],t_opt is Some T0.C: 'a... . T1 * ... * Tn -> T0 when
existentials is ['a;...],c_args is [T1; ... ; Tn],t_opt is Some T0.| Pext_rebind of Longident.t Asttypes.locPext_rebind(D) re-export the constructor D with the new name C
and class_type = {pcty_desc : class_type_desc;pcty_loc : Location.t;pcty_attributes : attributes;... [\@id1] [\@id2]
}and class_type_desc = | Pcty_constr of Longident.t Asttypes.loc * core_type listc['a1, ..., 'an] c| Pcty_signature of class_signatureobject ... end
| Pcty_arrow of Asttypes.arg_label * core_type * class_typePcty_arrow(lbl, T, CT) represents:
T -> CT when lbl is Nolabel,~l:T -> CT when lbl is Labelled l,?l:T -> CT when lbl is Optional l.| Pcty_extension of extension%id
| Pcty_open of open_description * class_typelet open M in CT
Values of type class_signature represents:
object('selfpat) ... endobject ... end when pcsig_self is Ptyp_anyand class_type_field = {pctf_desc : class_type_field_desc;pctf_loc : Location.t;pctf_attributes : attributes;... [\@\@id1] [\@\@id2]
}and class_type_field_desc = | Pctf_inherit of class_typeinherit CT
| Pctf_val of Asttypes.label Asttypes.loc
+ * Asttypes.mutable_flag
+ * Asttypes.virtual_flag
+ * core_typeval x: T
| Pctf_method of Asttypes.label Asttypes.loc
+ * Asttypes.private_flag
+ * Asttypes.virtual_flag
+ * core_type| Pctf_constraint of core_type * core_typeconstraint T1 = T2
| Pctf_attribute of attribute[\@\@\@id]
| Pctf_extension of extension[%%id]
and 'a class_infos = {pci_virt : Asttypes.virtual_flag;pci_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;pci_name : string Asttypes.loc;pci_expr : 'a;pci_loc : Location.t;pci_attributes : attributes;... [\@\@id1] [\@\@id2]
}Values of type class_expr class_infos represents:
class c = ...class ['a1,...,'an] c = ...class virtual c = ...They are also used for "class type" declaration.
and class_description = class_type class_infosand class_type_declaration = class_type class_infosand class_expr = {pcl_desc : class_expr_desc;pcl_loc : Location.t;pcl_attributes : attributes;... [\@id1] [\@id2]
}and class_expr_desc = | Pcl_constr of Longident.t Asttypes.loc * core_type listc and ['a1, ..., 'an] c
| Pcl_structure of class_structureobject ... end
| Pcl_fun of Asttypes.arg_label * expression option * pattern * class_exprPcl_fun(lbl, exp0, P, CE) represents:
fun P -> CE when lbl is Nolabel and exp0 is None,fun ~l:P -> CE when lbl is Labelled l and exp0 is None,fun ?l:P -> CE when lbl is Optional l and exp0 is None,fun ?l:(P = E0) -> CE when lbl is Optional l and exp0 is Some E0.| Pcl_apply of class_expr * (Asttypes.arg_label * expression) listPcl_apply(CE, [(l1,E1) ; ... ; (ln,En)]) represents CE ~l1:E1 ... ~ln:En. li can be empty (non labeled argument) or start with ? (optional argument).
Invariant: n > 0
| Pcl_let of Asttypes.rec_flag * value_binding list * class_exprPcl_let(rec, [(P1, E1); ... ; (Pn, En)], CE) represents:
let P1 = E1 and ... and Pn = EN in CE when rec is Nonrecursive,let rec P1 = E1 and ... and Pn = EN in CE when rec is Recursive.| Pcl_constraint of class_expr * class_type(CE : CT)
| Pcl_extension of extension[%id]
| Pcl_open of open_description * class_exprlet open M in CE
Values of type class_structure represents:
object(selfpat) ... endobject ... end when pcstr_self is Ppat_anyand class_field = {pcf_desc : class_field_desc;pcf_loc : Location.t;pcf_attributes : attributes;... [\@\@id1] [\@\@id2]
}and class_field_desc = | Pcf_inherit of Asttypes.override_flag * class_expr * string Asttypes.loc option| Pcf_val of Asttypes.label Asttypes.loc
+ * Asttypes.mutable_flag
+ * class_field_kindPcf_val(x,flag, kind) represents:
val x = E when flag is Immutable and kind is Cfk_concrete(Fresh, E)val virtual x: T when flag is Immutable and kind is Cfk_virtual(T)val mutable x = E when flag is Mutable and kind is Cfk_concrete(Fresh, E)val mutable virtual x: T when flag is Mutable and kind is Cfk_virtual(T)| Pcf_method of Asttypes.label Asttypes.loc
+ * Asttypes.private_flag
+ * class_field_kind| Pcf_constraint of core_type * core_typeconstraint T1 = T2
| Pcf_initializer of expressioninitializer E
| Pcf_attribute of attribute[\@\@\@id]
| Pcf_extension of extension[%%id]
and class_field_kind = | Cfk_virtual of core_type| Cfk_concrete of Asttypes.override_flag * expressionand class_declaration = class_expr class_infosand module_type = {pmty_desc : module_type_desc;pmty_loc : Location.t;pmty_attributes : attributes;... [\@id1] [\@id2]
}and module_type_desc = | Pmty_ident of Longident.t Asttypes.locPmty_ident(S) represents S
| Pmty_signature of signaturesig ... end
| Pmty_functor of functor_parameter * module_typefunctor(X : MT1) -> MT2
| Pmty_with of module_type * with_constraint listMT with ...
| Pmty_typeof of module_exprmodule type of ME
| Pmty_extension of extension[%id]
| Pmty_alias of Longident.t Asttypes.loc(module M)
and functor_parameter = | Unit()
| Named of string option Asttypes.loc * module_typeNamed(name, MT) represents:
(X : MT) when name is Some X,(_ : MT) when name is Noneand signature = signature_item listand signature_item_desc = | Psig_value of value_descriptionval x: Texternal x: T = "s1" ... "sn"| Psig_type of Asttypes.rec_flag * type_declaration listtype t1 = ... and ... and tn = ...
| Psig_typesubst of type_declaration listtype t1 := ... and ... and tn := ...
| Psig_typext of type_extensiontype t1 += ...
| Psig_exception of type_exceptionexception C of T
| Psig_module of module_declarationmodule X = M and module X : MT
| Psig_modsubst of module_substitutionmodule X := M
| Psig_recmodule of module_declaration listmodule rec X1 : MT1 and ... and Xn : MTn
| Psig_modtype of module_type_declarationmodule type S = MT and module type S
| Psig_modtypesubst of module_type_declarationmodule type S := ...
| Psig_open of open_descriptionopen X
| Psig_include of include_descriptioninclude MT
| Psig_class of class_description listclass c1 : ... and ... and cn : ...
| Psig_class_type of class_type_declaration listclass type ct1 = ... and ... and ctn = ...
| Psig_attribute of attribute[\@\@\@id]
| Psig_extension of extension * attributes[%%id]
and module_declaration = {pmd_name : string option Asttypes.loc;pmd_type : module_type;pmd_attributes : attributes;... [\@\@id1] [\@\@id2]
pmd_loc : Location.t;}Values of type module_declaration represents S : MT
and module_substitution = {pms_name : string Asttypes.loc;pms_manifest : Longident.t Asttypes.loc;pms_attributes : attributes;... [\@\@id1] [\@\@id2]
pms_loc : Location.t;}Values of type module_substitution represents S := M
and module_type_declaration = {pmtd_name : string Asttypes.loc;pmtd_type : module_type option;pmtd_attributes : attributes;... [\@\@id1] [\@\@id2]
pmtd_loc : Location.t;}Values of type module_type_declaration represents:
S = MT,S for abstract module type declaration, when pmtd_type is None.and 'a open_infos = {popen_expr : 'a;popen_override : Asttypes.override_flag;popen_loc : Location.t;popen_attributes : attributes;}Values of type 'a open_infos represents:
open! X when popen_override is Override (silences the "used identifier shadowing" warning)open X when popen_override is Freshand open_description = Longident.t Asttypes.loc open_infosValues of type open_description represents:
open M.Nopen M(N).Oand open_declaration = module_expr open_infosValues of type open_declaration represents:
open M.Nopen M(N).Oopen struct ... endand include_description = module_type include_infosValues of type include_description represents include MT
and include_declaration = module_expr include_infosValues of type include_declaration represents include ME
and with_constraint = | Pwith_type of Longident.t Asttypes.loc * type_declarationwith type X.t = ...
Note: the last component of the longident must match the name of the type_declaration.
*)| Pwith_module of Longident.t Asttypes.loc * Longident.t Asttypes.locwith module X.Y = Z
| Pwith_modtype of Longident.t Asttypes.loc * module_typewith module type X.Y = Z
| Pwith_modtypesubst of Longident.t Asttypes.loc * module_typewith module type X.Y := sig end
| Pwith_typesubst of Longident.t Asttypes.loc * type_declarationwith type X.t := ..., same format as [Pwith_type]
| Pwith_modsubst of Longident.t Asttypes.loc * Longident.t Asttypes.locwith module X.Y := Z
and module_expr = {pmod_desc : module_expr_desc;pmod_loc : Location.t;pmod_attributes : attributes;... [\@id1] [\@id2]
}and module_expr_desc = | Pmod_ident of Longident.t Asttypes.locX
| Pmod_structure of structurestruct ... end
| Pmod_functor of functor_parameter * module_exprfunctor(X : MT1) -> ME
| Pmod_apply of module_expr * module_exprME1(ME2)
| Pmod_constraint of module_expr * module_type(ME : MT)
| Pmod_unpack of expression(val E)
| Pmod_extension of extension[%id]
and structure = structure_item listand structure_item_desc = | Pstr_eval of expression * attributesE
| Pstr_value of Asttypes.rec_flag * value_binding listPstr_value(rec, [(P1, E1 ; ... ; (Pn, En))]) represents:
let P1 = E1 and ... and Pn = EN when rec is Nonrecursive,let rec P1 = E1 and ... and Pn = EN when rec is Recursive.| Pstr_primitive of value_descriptionval x: Texternal x: T = "s1" ... "sn" | Pstr_type of Asttypes.rec_flag * type_declaration listtype t1 = ... and ... and tn = ...
| Pstr_typext of type_extensiontype t1 += ...
| Pstr_exception of type_exceptionexception C of Texception C = M.X| Pstr_module of module_bindingmodule X = ME
| Pstr_recmodule of module_binding listmodule rec X1 = ME1 and ... and Xn = MEn
| Pstr_modtype of module_type_declarationmodule type S = MT
| Pstr_open of open_declarationopen X
| Pstr_class of class_declaration listclass c1 = ... and ... and cn = ...
| Pstr_class_type of class_type_declaration listclass type ct1 = ... and ... and ctn = ...
| Pstr_include of include_declarationinclude ME
| Pstr_attribute of attribute[\@\@\@id]
| Pstr_extension of extension * attributes[%%id]
and value_binding = {pvb_pat : pattern;pvb_expr : expression;pvb_attributes : attributes;pvb_loc : Location.t;}and module_binding = {pmb_name : string option Asttypes.loc;pmb_expr : module_expr;pmb_attributes : attributes;pmb_loc : Location.t;}Values of type module_binding represents module X = ME
and toplevel_directive = {pdir_name : string Asttypes.loc;pdir_arg : directive_argument option;pdir_loc : Location.t;}and directive_argument_desc = | Pdir_string of string| Pdir_int of string * char option| Pdir_ident of Longident.t| Pdir_bool of boolPass_wrapperval with_dump :
+ ppf_dump:Stdlib.Format.formatter ->
+ pass_name:string ->
+ f:(unit -> 'b option) ->
+ input:'a ->
+ print_input:(Stdlib.Format.formatter -> 'a -> unit) ->
+ print_output:(Stdlib.Format.formatter -> 'b -> unit) ->
+ 'b optionPath.Maptype key = tThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Path.Settype elt = tThe type of the set elements.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Pathval scope : t -> intval name : ?paren:(string -> bool) -> t -> stringval print : Stdlib.Format.formatter -> t -> unitval last : t -> stringval is_constructor_typath : t -> boolPatterns.Generaltype view = [ | Half_simple.view| `Var of Ident.t * string Asttypes.loc| `Alias of Typedtree.pattern * Ident.t * string Asttypes.loc ]type pattern = view Typedtree.pattern_dataval view : Typedtree.pattern -> patternval erase : [< view ] Typedtree.pattern_data -> Typedtree.patternval strip_vars : pattern -> Half_simple.patternPatterns.Half_simpletype pattern = view Typedtree.pattern_dataPatterns.Headtype desc = | Any| Construct of Types.constructor_description| Constant of Asttypes.constant| Tuple of int| Record of Types.label_description list| Variant of {tag : Asttypes.label;has_arg : bool;cstr_row : Types.row_desc ref;type_row : unit -> Types.row_desc;}| Array of int| Lazytype t = desc Typedtree.pattern_dataval arity : t -> intval deconstruct : Simple.pattern -> t * Typedtree.pattern listdeconstruct p returns the head of p and the list of sub patterns.
val to_omega_pattern : t -> Typedtree.patternreconstructs a pattern, putting wildcards as sub-patterns.
val omega : tPatterns.Non_empty_rowtype 'a t = 'a * Typedtree.pattern listval of_initial : Typedtree.pattern list -> Typedtree.pattern t'assert false' on empty rows
Patterns.Simpletype view = [ | `Any| `Constant of Asttypes.constant| `Tuple of Typedtree.pattern list| `Construct of
+ Longident.t Asttypes.loc
+ * Types.constructor_description
+ * Typedtree.pattern list| `Variant of Asttypes.label * Typedtree.pattern option * Types.row_desc ref| `Record of
+ (Longident.t Asttypes.loc * Types.label_description * Typedtree.pattern) list
+ * Asttypes.closed_flag| `Array of Typedtree.pattern list| `Lazy of Typedtree.pattern ]type pattern = view Typedtree.pattern_dataval omega : [> view ] Typedtree.pattern_dataPatternsval omega : Typedtree.patternaka. "Tpat_any" or "_"
val omegas : int -> Typedtree.pattern listList.init (fun _ -> omega)
val omega_list : 'a list -> Typedtree.pattern listList.map (fun _ -> omega)
module Non_empty_row : sig ... endmodule Simple : sig ... endmodule Half_simple : sig ... endmodule General : sig ... endmodule Head : sig ... endPersistent_env.Consistbltype t = Consistbl.Make(Misc.Stdlib.String).tval create : unit -> tval clear : t -> unitval check :
+ t ->
+ Misc.Stdlib.String.t ->
+ Stdlib.Digest.t ->
+ Misc.filepath ->
+ unitval check_noadd :
+ t ->
+ Misc.Stdlib.String.t ->
+ Stdlib.Digest.t ->
+ Misc.filepath ->
+ unitval set : t -> Misc.Stdlib.String.t -> Stdlib.Digest.t -> Misc.filepath -> unitval source : t -> Misc.Stdlib.String.t -> Misc.filepathval extract :
+ Misc.Stdlib.String.t list ->
+ t ->
+ (Misc.Stdlib.String.t * Stdlib.Digest.t option) listval extract_map :
+ Misc.Stdlib.String.Set.t ->
+ t ->
+ Stdlib.Digest.t option Misc.Stdlib.String.Map.tval filter : (Misc.Stdlib.String.t -> bool) -> t -> unitexception Inconsistency of {unit_name : Misc.Stdlib.String.t;inconsistent_source : string;original_source : string;}exception Not_available of Misc.Stdlib.String.tPersistent_env.Persistent_signaturetype t = {filename : string;Name of the file containing the signature.
*)cmi : Cmi_format.cmi_infos;}Persistent_envmodule Consistbl :
+ module type of struct include Consistbl.Make(Misc.Stdlib.String) endtype error = | Illegal_renaming of Misc.modname * Misc.modname * Misc.filepath| Inconsistent_import of Misc.modname * Misc.filepath * Misc.filepath| Need_recursive_types of Misc.modname| Depend_on_unsafe_string_unit of Misc.modnameexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitmodule Persistent_signature : sig ... endval empty : unit -> 'a tval clear : 'a t -> unitval clear_missing : 'a t -> unitval fold : 'a t -> (Misc.modname -> 'a -> 'b -> 'b) -> 'b -> 'bval read :
+ 'a t ->
+ (Persistent_signature.t -> 'a) ->
+ Misc.modname ->
+ Misc.filepath ->
+ 'aval find : 'a t -> (Persistent_signature.t -> 'a) -> Misc.modname -> 'aval find_in_cache : 'a t -> Misc.modname -> 'a optionval check :
+ 'a t ->
+ (Persistent_signature.t -> 'a) ->
+ loc:Location.t ->
+ Misc.modname ->
+ unitval looked_up : 'a t -> Misc.modname -> boolval is_imported : 'a t -> Misc.modname -> boolval is_imported_opaque : 'a t -> Misc.modname -> boolval register_import_as_opaque : 'a t -> Misc.modname -> unitval make_cmi :
+ 'a t ->
+ Misc.modname ->
+ Types.signature ->
+ Misc.alerts ->
+ Cmi_format.cmi_infosval save_cmi : 'a t -> Persistent_signature.t -> 'a -> unitval can_load_cmis : 'a t -> can_load_cmisval set_can_load_cmis : 'a t -> can_load_cmis -> unitval without_cmis : 'a t -> ('b -> 'c) -> 'b -> 'cval import_crcs : 'a t -> source:Misc.filepath -> Misc.crcs -> unitval crc_of_unit :
+ 'a t ->
+ (Persistent_signature.t -> 'a) ->
+ Misc.modname ->
+ Stdlib.Digest.tval add_delayed_check_forward : ((unit -> unit) -> unit) refPollingAnalyses related to the insertion of Ipoll operations.
val instrument_fundecl :
+ future_funcnames:Misc.Stdlib.String.Set.t ->
+ Mach.fundecl ->
+ Mach.fundeclval requires_prologue_poll :
+ future_funcnames:Misc.Stdlib.String.Set.t ->
+ fun_name:string ->
+ Mach.instruction ->
+ boolPparseDriver for the parser and external preprocessors.
Warning: this module is unstable and part of compiler-libs.
exception Error of errortype 'a ast_kind = | Structure : Parsetree.structure ast_kind| Signature : Parsetree.signature ast_kindval read_ast : 'a ast_kind -> string -> 'aval write_ast : 'a ast_kind -> string -> 'a -> unitval file :
+ tool_name:string ->
+ string ->
+ (Stdlib.Lexing.lexbuf -> 'a) ->
+ 'a ast_kind ->
+ 'aval apply_rewriters :
+ ?restore:bool ->
+ tool_name:string ->
+ 'a ast_kind ->
+ 'a ->
+ 'aIf restore = true (the default), cookies set by external rewriters will be kept for later calls.
val apply_rewriters_str :
+ ?restore:bool ->
+ tool_name:string ->
+ Parsetree.structure ->
+ Parsetree.structureval apply_rewriters_sig :
+ ?restore:bool ->
+ tool_name:string ->
+ Parsetree.signature ->
+ Parsetree.signatureval report_error : Stdlib.Format.formatter -> error -> unitval parse_implementation : tool_name:string -> string -> Parsetree.structureval parse_interface : tool_name:string -> string -> Parsetree.signatureval open_and_check_magic : string -> string -> in_channel * boolPprintastPretty-printers for Parsetree
Warning: this module is unstable and part of compiler-libs.
type space_formatter = (unit, Stdlib.Format.formatter, unit) formatval longident : Stdlib.Format.formatter -> Longident.t -> unitval expression : Stdlib.Format.formatter -> Parsetree.expression -> unitval string_of_expression : Parsetree.expression -> stringval pattern : Stdlib.Format.formatter -> Parsetree.pattern -> unitval core_type : Stdlib.Format.formatter -> Parsetree.core_type -> unitval signature : Stdlib.Format.formatter -> Parsetree.signature -> unitval structure : Stdlib.Format.formatter -> Parsetree.structure -> unitval string_of_structure : Parsetree.structure -> stringval module_expr : Stdlib.Format.formatter -> Parsetree.module_expr -> unitval toplevel_phrase :
+ Stdlib.Format.formatter ->
+ Parsetree.toplevel_phrase ->
+ unitval top_phrase : Stdlib.Format.formatter -> Parsetree.toplevel_phrase -> unitval class_field : Stdlib.Format.formatter -> Parsetree.class_field -> unitval class_type_field :
+ Stdlib.Format.formatter ->
+ Parsetree.class_type_field ->
+ unitval class_expr : Stdlib.Format.formatter -> Parsetree.class_expr -> unitval class_type : Stdlib.Format.formatter -> Parsetree.class_type -> unitval module_type : Stdlib.Format.formatter -> Parsetree.module_type -> unitval structure_item :
+ Stdlib.Format.formatter ->
+ Parsetree.structure_item ->
+ unitval signature_item :
+ Stdlib.Format.formatter ->
+ Parsetree.signature_item ->
+ unitval binding : Stdlib.Format.formatter -> Parsetree.value_binding -> unitval payload : Stdlib.Format.formatter -> Parsetree.payload -> unitval tyvar : Stdlib.Format.formatter -> string -> unitPrint a type variable name, taking care of the special treatment required for the single quote character in second position.
Predefval type_int : Types.type_exprval type_char : Types.type_exprval type_string : Types.type_exprval type_bytes : Types.type_exprval type_float : Types.type_exprval type_bool : Types.type_exprval type_unit : Types.type_exprval type_exn : Types.type_exprval type_array : Types.type_expr -> Types.type_exprval type_list : Types.type_expr -> Types.type_exprval type_option : Types.type_expr -> Types.type_exprval type_nativeint : Types.type_exprval type_int32 : Types.type_exprval type_int64 : Types.type_exprval type_lazy_t : Types.type_expr -> Types.type_exprval type_extension_constructor : Types.type_exprval type_floatarray : Types.type_exprval path_int : Path.tval path_char : Path.tval path_string : Path.tval path_bytes : Path.tval path_float : Path.tval path_bool : Path.tval path_unit : Path.tval path_exn : Path.tval path_array : Path.tval path_list : Path.tval path_option : Path.tval path_nativeint : Path.tval path_int32 : Path.tval path_int64 : Path.tval path_lazy_t : Path.tval path_extension_constructor : Path.tval path_floatarray : Path.tval path_match_failure : Path.tval path_assert_failure : Path.tval path_undefined_recursive_module : Path.tval ident_false : Ident.tval ident_true : Ident.tval ident_void : Ident.tval ident_nil : Ident.tval ident_cons : Ident.tval ident_none : Ident.tval ident_some : Ident.tval build_initial_env :
+ (Ident.t -> Types.type_declaration -> 'a -> 'a) ->
+ (Ident.t -> Types.extension_constructor -> 'a -> 'a) ->
+ 'a ->
+ 'a * 'aval builtin_values : (string * Ident.t) listval builtin_idents : (string * Ident.t) listval ident_division_by_zero : Ident.tAll predefined exceptions, exposed as Ident.t for flambda (for building value approximations). The Ident.t for division by zero is also exported explicitly so flambda can generate code to raise it.
val all_predef_exns : Ident.t listPrimitivetype native_repr = | Same_as_ocaml_repr| Unboxed_float| Unboxed_integer of boxed_integer| Untagged_inttype description = private {prim_name : string;prim_arity : int;prim_alloc : bool;prim_native_name : string;prim_native_repr_args : native_repr list;prim_native_repr_res : native_repr;}val simple : name:string -> arity:int -> alloc:bool -> descriptionval make :
+ name:string ->
+ alloc:bool ->
+ native_name:string ->
+ native_repr_args:native_repr list ->
+ native_repr_res:native_repr ->
+ descriptionval parse_declaration :
+ Parsetree.value_description ->
+ native_repr_args:native_repr list ->
+ native_repr_res:native_repr ->
+ descriptionval print : description -> Outcometree.out_val_decl -> Outcometree.out_val_declval native_name : description -> stringval byte_name : description -> stringval equal_boxed_integer : boxed_integer -> boxed_integer -> boolval equal_native_repr : native_repr -> native_repr -> boolval native_name_is_external : description -> boolnative_name_is_externa returns true iff the native_name for the given primitive identifies that the primitive is not implemented in the compiler itself.
exception Error of Location.t * errorPrintastRaw printer for Parsetree
Warning: this module is unstable and part of compiler-libs.
val interface :
+ Stdlib.Format.formatter ->
+ Parsetree.signature_item list ->
+ unitval implementation :
+ Stdlib.Format.formatter ->
+ Parsetree.structure_item list ->
+ unitval top_phrase : Stdlib.Format.formatter -> Parsetree.toplevel_phrase -> unitval expression : int -> Stdlib.Format.formatter -> Parsetree.expression -> unitval structure : int -> Stdlib.Format.formatter -> Parsetree.structure -> unitval payload : int -> Stdlib.Format.formatter -> Parsetree.payload -> unitPrintclambdaval clambda : Stdlib.Format.formatter -> Clambda.ulambda -> unitval approx : Stdlib.Format.formatter -> Clambda.value_approximation -> unitval structured_constant :
+ Stdlib.Format.formatter ->
+ Clambda.ustructured_constant ->
+ unitval phantom_defining_expr_opt :
+ Stdlib.Format.formatter ->
+ Clambda.uphantom_defining_expr option ->
+ unitPrintclambda_primitivesval primitive : Stdlib.Format.formatter -> Clambda_primitives.primitive -> unitPrintcmmval rec_flag : Stdlib.Format.formatter -> Cmm.rec_flag -> unitval machtype_component :
+ Stdlib.Format.formatter ->
+ Cmm.machtype_component ->
+ unitval machtype : Stdlib.Format.formatter -> Cmm.machtype -> unitval exttype : Stdlib.Format.formatter -> Cmm.exttype -> unitval extcall_signature :
+ Stdlib.Format.formatter ->
+ (Cmm.machtype * Cmm.exttype list) ->
+ unitval integer_comparison : Cmm.integer_comparison -> stringval float_comparison : Cmm.float_comparison -> stringval chunk : Cmm.memory_chunk -> stringval operation : Debuginfo.t -> Cmm.operation -> stringval expression : Stdlib.Format.formatter -> Cmm.expression -> unitval fundecl : Stdlib.Format.formatter -> Cmm.fundecl -> unitval data : Stdlib.Format.formatter -> Cmm.data_item list -> unitval phrase : Stdlib.Format.formatter -> Cmm.phrase -> unitPrintinstrval instruction : Stdlib.Format.formatter -> Instruct.instruction -> unitval instrlist : Stdlib.Format.formatter -> Instruct.instruction list -> unitPrintlambdaval integer_comparison :
+ Stdlib.Format.formatter ->
+ Lambda.integer_comparison ->
+ unitval float_comparison :
+ Stdlib.Format.formatter ->
+ Lambda.float_comparison ->
+ unitval structured_constant :
+ Stdlib.Format.formatter ->
+ Lambda.structured_constant ->
+ unitval lambda : Stdlib.Format.formatter -> Lambda.lambda -> unitval program : Stdlib.Format.formatter -> Lambda.program -> unitval primitive : Stdlib.Format.formatter -> Lambda.primitive -> unitval name_of_primitive : Lambda.primitive -> stringval value_kind : Stdlib.Format.formatter -> Lambda.value_kind -> unitval block_shape :
+ Stdlib.Format.formatter ->
+ Lambda.value_kind list option ->
+ unitval record_rep : Stdlib.Format.formatter -> Types.record_representation -> unitval print_bigarray :
+ string ->
+ bool ->
+ Lambda.bigarray_kind ->
+ Stdlib.Format.formatter ->
+ Lambda.bigarray_layout ->
+ unitPrintlinearval instr : Stdlib.Format.formatter -> Linear.instruction -> unitval fundecl : Stdlib.Format.formatter -> Linear.fundecl -> unitPrintmachval reg : Stdlib.Format.formatter -> Reg.t -> unitval regs : Stdlib.Format.formatter -> Reg.t array -> unitval regset : Stdlib.Format.formatter -> Reg.Set.t -> unitval regsetaddr : Stdlib.Format.formatter -> Reg.Set.t -> unitval operation :
+ Mach.operation ->
+ Reg.t array ->
+ Stdlib.Format.formatter ->
+ Reg.t array ->
+ unitval test : Mach.test -> Stdlib.Format.formatter -> Reg.t array -> unitval instr : Stdlib.Format.formatter -> Mach.instruction -> unitval fundecl : Stdlib.Format.formatter -> Mach.fundecl -> unitval phase : string -> Stdlib.Format.formatter -> Mach.fundecl -> unitval interferences : Stdlib.Format.formatter -> unit -> unitval intervals : Stdlib.Format.formatter -> unit -> unitval preferences : Stdlib.Format.formatter -> unit -> unitPrintpatval pretty_const : Asttypes.constant -> stringval top_pretty :
+ Stdlib.Format.formatter ->
+ 'k Typedtree.general_pattern ->
+ unitval pretty_pat : 'k Typedtree.general_pattern -> unitval pretty_line :
+ Stdlib.Format.formatter ->
+ 'k Typedtree.general_pattern list ->
+ unitval pretty_matrix :
+ Stdlib.Format.formatter ->
+ 'k Typedtree.general_pattern list list ->
+ unitPrinttyp.ConflictsThe Conflicts module keeps track of conflicts arising when attributing names to identifiers and provides functions that can print explanations for these conflict in error messages
exists() returns true if the current naming context renamed an identifier to avoid a name collision
val list_explanations : unit -> explanation listlist_explanations() return the list of conflict explanations collected up to this point, and reset the list of collected explanations
val print_located_explanations :
+ Stdlib.Format.formatter ->
+ explanation list ->
+ unitval print_explanations : Stdlib.Format.formatter -> unitPrint all conflict explanations collected up to this point
Printtyp.Naming_contextWhen contextual names are enabled, the mapping between identifiers and names is ensured to be one-to-one.
Printtyp.Out_nameval create : string -> Outcometree.out_nameval print : Outcometree.out_name -> stringPrinttyp.Subtypeval report_error :
+ Stdlib.Format.formatter ->
+ Env.t ->
+ Errortrace.Subtype.error ->
+ string ->
+ unitPrinttypval longident : Stdlib.Format.formatter -> Longident.t -> unitval ident : Stdlib.Format.formatter -> Ident.t -> unitval tree_of_path : Path.t -> Outcometree.out_identval path : Stdlib.Format.formatter -> Path.t -> unitval string_of_path : Path.t -> stringval type_path : Stdlib.Format.formatter -> Path.t -> unitPrint a type path taking account of -short-paths. Calls should be within wrap_printing_env.
module Out_name : sig ... endPrint a list of paths, using the same naming context to avoid name collisions
val raw_type_expr : Stdlib.Format.formatter -> Types.type_expr -> unitval string_of_label : Asttypes.arg_label -> stringval wrap_printing_env : error:bool -> Env.t -> (unit -> 'a) -> 'amodule Naming_context : sig ... endmodule Conflicts : sig ... endThe Conflicts module keeps track of conflicts arising when attributing names to identifiers and provides functions that can print explanations for these conflict in error messages
val type_expr : Stdlib.Format.formatter -> Types.type_expr -> unitPrint out a type. This will pick names for type variables, and will not reuse names for common type variables shared across multiple type expressions. (It will also reset the printing state, which matters for other type formatters such as prepared_type_expr.) If you want multiple types to use common names for type variables, see prepare_for_printing and prepared_type_expr.
val prepare_for_printing : Types.type_expr list -> unitprepare_for_printing resets the global printing environment, a la reset, and prepares the types for printing by reserving names and marking loops. Any type variables that are shared between multiple types in the input list will be given the same name when printed with prepared_type_expr.
val add_type_to_preparation : Types.type_expr -> unitadd_type_to_preparation ty extend a previous type expression preparation to the type expression ty
val prepared_type_expr : Stdlib.Format.formatter -> Types.type_expr -> unitThe function prepared_type_expr is a less-safe but more-flexible version of type_expr that should only be called on type_exprs that have been passed to prepare_for_printing. Unlike type_expr, this function does no extra work before printing a type; in particular, this means that any loops in the type expression may cause a stack overflow (see #8860) since this function does not mark any loops. The benefit of this is that if multiple type expressions are prepared simultaneously and then printed with prepared_type_expr, they will use the same names for the same type variables.
val constructor_arguments :
+ Stdlib.Format.formatter ->
+ Types.constructor_arguments ->
+ unitval tree_of_type_scheme : Types.type_expr -> Outcometree.out_typeval type_scheme : Stdlib.Format.formatter -> Types.type_expr -> unitshared_type_scheme is very similar to type_scheme, but does not reset the printing context first. This is intended to be used in cases where the printing should have a particularly wide context, such as documentation generators; most use cases, such as error messages, have narrower contexts for which type_scheme is better suited.
val tree_of_value_description :
+ Ident.t ->
+ Types.value_description ->
+ Outcometree.out_sig_itemval value_description :
+ Ident.t ->
+ Stdlib.Format.formatter ->
+ Types.value_description ->
+ unitval label : Stdlib.Format.formatter -> Types.label_declaration -> unitval constructor :
+ Stdlib.Format.formatter ->
+ Types.constructor_declaration ->
+ unitval tree_of_type_declaration :
+ Ident.t ->
+ Types.type_declaration ->
+ Types.rec_status ->
+ Outcometree.out_sig_itemval type_declaration :
+ Ident.t ->
+ Stdlib.Format.formatter ->
+ Types.type_declaration ->
+ unitval tree_of_extension_constructor :
+ Ident.t ->
+ Types.extension_constructor ->
+ Types.ext_status ->
+ Outcometree.out_sig_itemval extension_constructor :
+ Ident.t ->
+ Stdlib.Format.formatter ->
+ Types.extension_constructor ->
+ unitval extension_only_constructor :
+ Ident.t ->
+ Stdlib.Format.formatter ->
+ Types.extension_constructor ->
+ unitval tree_of_module :
+ Ident.t ->
+ ?ellipsis:bool ->
+ Types.module_type ->
+ Types.rec_status ->
+ Outcometree.out_sig_itemval modtype : Stdlib.Format.formatter -> Types.module_type -> unitval signature : Stdlib.Format.formatter -> Types.signature -> unitval tree_of_modtype : Types.module_type -> Outcometree.out_module_typeval tree_of_modtype_declaration :
+ Ident.t ->
+ Types.modtype_declaration ->
+ Outcometree.out_sig_itemval functor_parameters :
+ sep:(Stdlib.Format.formatter -> unit -> unit) ->
+ ('b -> Stdlib.Format.formatter -> unit) ->
+ (Ident.t option * 'b) list ->
+ Stdlib.Format.formatter ->
+ unitPrint a list of functor parameters while adjusting the printing environment for each functor argument.
Currently, we are disabling disambiguation for functor argument name to avoid the need to track the moving association between identifiers and syntactic names in situation like:
got: (X: sig module type T end) (Y:X.T) (X:sig module type T end) (Z:X.T) expect: (_: sig end) (Y:X.T) (_:sig end) (Z:X.T)
val tree_of_signature : Types.signature -> Outcometree.out_sig_item listval tree_of_typexp : type_or_scheme -> Types.type_expr -> Outcometree.out_typeval modtype_declaration :
+ Ident.t ->
+ Stdlib.Format.formatter ->
+ Types.modtype_declaration ->
+ unitval class_type : Stdlib.Format.formatter -> Types.class_type -> unitval tree_of_class_declaration :
+ Ident.t ->
+ Types.class_declaration ->
+ Types.rec_status ->
+ Outcometree.out_sig_itemval class_declaration :
+ Ident.t ->
+ Stdlib.Format.formatter ->
+ Types.class_declaration ->
+ unitval tree_of_cltype_declaration :
+ Ident.t ->
+ Types.class_type_declaration ->
+ Types.rec_status ->
+ Outcometree.out_sig_itemval cltype_declaration :
+ Ident.t ->
+ Stdlib.Format.formatter ->
+ Types.class_type_declaration ->
+ unitval type_expansion :
+ type_or_scheme ->
+ Stdlib.Format.formatter ->
+ Errortrace.expanded_type ->
+ unitval prepare_expansion : Errortrace.expanded_type -> Errortrace.expanded_typeval report_ambiguous_type_error :
+ Stdlib.Format.formatter ->
+ Env.t ->
+ (Path.t * Path.t) ->
+ (Path.t * Path.t) list ->
+ (Stdlib.Format.formatter -> unit) ->
+ (Stdlib.Format.formatter -> unit) ->
+ (Stdlib.Format.formatter -> unit) ->
+ unitval report_unification_error :
+ Stdlib.Format.formatter ->
+ Env.t ->
+ Errortrace.unification_error ->
+ ?type_expected_explanation:(Stdlib.Format.formatter -> unit) ->
+ (Stdlib.Format.formatter -> unit) ->
+ (Stdlib.Format.formatter -> unit) ->
+ unitval report_equality_error :
+ Stdlib.Format.formatter ->
+ type_or_scheme ->
+ Env.t ->
+ Errortrace.equality_error ->
+ (Stdlib.Format.formatter -> unit) ->
+ (Stdlib.Format.formatter -> unit) ->
+ unitval report_moregen_error :
+ Stdlib.Format.formatter ->
+ type_or_scheme ->
+ Env.t ->
+ Errortrace.moregen_error ->
+ (Stdlib.Format.formatter -> unit) ->
+ (Stdlib.Format.formatter -> unit) ->
+ unitval report_comparison_error :
+ Stdlib.Format.formatter ->
+ type_or_scheme ->
+ Env.t ->
+ Errortrace.comparison_error ->
+ (Stdlib.Format.formatter -> unit) ->
+ (Stdlib.Format.formatter -> unit) ->
+ unitmodule Subtype : sig ... endval print_items :
+ (Env.t -> Types.signature_item -> 'a option) ->
+ Env.t ->
+ Types.signature_item list ->
+ (Outcometree.out_sig_item * 'a option) listval printed_signature :
+ string ->
+ Stdlib.Format.formatter ->
+ Types.signature ->
+ unitprinted_signature sourcefile ppf sg print the signature sg of sourcefile with potential warnings for name collisions
Printtypedval interface : Stdlib.Format.formatter -> Typedtree.signature -> unitval implementation : Stdlib.Format.formatter -> Typedtree.structure -> unitval implementation_with_coercion :
+ Stdlib.Format.formatter ->
+ Typedtree.implementation ->
+ unitProcval register_class : Reg.t -> intval phys_reg : int -> Reg.tval loc_arguments : Cmm.machtype -> Reg.t array * intval loc_results : Cmm.machtype -> Reg.t arrayval loc_parameters : Cmm.machtype -> Reg.t arrayval loc_external_arguments : Cmm.exttype list -> Reg.t array array * intval loc_external_results : Cmm.machtype -> Reg.t arrayval loc_exn_bucket : Reg.tval safe_register_pressure : Mach.operation -> intval max_register_pressure : Mach.operation -> int arrayval destroyed_at_oper : Mach.instruction_desc -> Reg.t arrayval destroyed_at_raise : Reg.t arrayval destroyed_at_reloadretaddr : Reg.t arrayval regs_are_volatile : Reg.t array -> boolval frame_required : Mach.fundecl -> boolval prologue_required : Mach.fundecl -> boolFor a given register class, the DWARF register numbering for that class. Given an allocated register with location Reg n and class reg_class, the returned array contains the corresponding DWARF register number at index n - first_available_register.(reg_class).
The DWARF register number corresponding to the stack pointer.
ProfileCompiler performance recording
Warning: this module is unstable and part of compiler-libs.
record_call pass f calls f and records its profile information.
record pass f arg records the profile information of f arg
val print : Stdlib.Format.formatter -> column list -> unitPrints the selected recorded profiling information to the formatter.
Command line flags
val all_columns : column listA few pass names that are needed in several places, and shared to avoid typos.
Profilingval counters : (string * (string * int array)) list refProjection.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitProjection.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringProjection.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitProjection.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tProjectionRepresentation of projections from closures and blocks.
type project_closure = {set_of_closures : Variable.t;must yield a set of closures
*)closure_id : Closure_id.t;}The selection of one closure given a set of closures, required before a function defined by said set of closures can be applied. See more detailed documentation below on set_of_closures.
type move_within_set_of_closures = {closure : Variable.t;must yield a closure
*)start_from : Closure_id.t;move_to : Closure_id.t;}The selection of one closure given another closure in the same set of closures. See more detailed documentation below on set_of_closures. The move_to closure must be part of the free variables of start_from.
type project_var = {closure : Variable.t;must yield a closure
*)closure_id : Closure_id.t;var : Var_within_closure.t;}The selection from a closure of a variable bound by said closure. In other words, access to a function's environment. Also see more detailed documentation below on set_of_closures.
val print_project_closure : Stdlib.Format.formatter -> project_closure -> unitval print_move_within_set_of_closures :
+ Stdlib.Format.formatter ->
+ move_within_set_of_closures ->
+ unitval print_project_var : Stdlib.Format.formatter -> project_var -> unitval compare_project_var : project_var -> project_var -> intval compare_project_closure : project_closure -> project_closure -> intval compare_move_within_set_of_closures :
+ move_within_set_of_closures ->
+ move_within_set_of_closures ->
+ inttype t = | Project_var of project_var| Project_closure of project_closure| Move_within_set_of_closures of move_within_set_of_closures| Field of int * Variable.tinclude Identifiable.S with type t := tmodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval projecting_from : t -> Variable.tReturn which variable the given projection projects from.
val map_projecting_from : t -> f:(Variable.t -> Variable.t) -> tChange the variable that the given projection projects from.
Rec_checkval is_valid_recursive_expression :
+ Ident.t list ->
+ Typedtree.expression ->
+ boolval is_valid_class_expr : Ident.t list -> Typedtree.class_expr -> boolRef_to_variablesTransform let-bound references into variables.
val eliminate_ref : Flambda.program -> Flambda.programReg.Maptype key = tThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Reg.Raw_nameval create_from_var : Backend_var.t -> tReg.Settype elt = tThe type of the set elements.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Regmodule Raw_name : sig ... endtype t = {mutable raw_name : Raw_name.t;stamp : int;typ : Cmm.machtype_component;mutable loc : location;mutable spill : bool;mutable part : int option;mutable interf : t list;mutable prefer : (t * int) list;mutable degree : int;mutable spill_cost : int;mutable visited : int;}val dummy : tval create : Cmm.machtype_component -> tval createv : Cmm.machtype -> t arrayval at_location : Cmm.machtype_component -> location -> tval typv : t array -> Cmm.machtypeval anonymous : t -> boolval name : t -> stringval all_registers : unit -> t listval mark_visited : t -> unitval is_visited : t -> boolReloadval fundecl : Mach.fundecl -> int array -> Mach.fundecl * boolReloadgen.reload_genericmethod reload_operation : Mach.operation ->
+ Reg.t array ->
+ Reg.t array ->
+ Reg.t array * Reg.t arraymethod fundecl : Mach.fundecl -> int array -> Mach.fundecl * boolReloadgenclass reload_generic : object ... endRemove_free_vars_equal_to_argsReplace free variables in closures known to be equal to specialised arguments of such closures with those specialised arguments.
val run :
+ ppf_dump:Stdlib.Format.formatter ->
+ Flambda.set_of_closures ->
+ Flambda.set_of_closures optionRemove_unused_argumentsval separate_unused_arguments_in_closures :
+ Flambda.program ->
+ backend:(module Backend_intf.S) ->
+ Flambda.programIntroduce a stub function to avoid depending on unused arguments.
For instance, it turns let rec fact n unused =
+ if n = 0 then 1
+ else n * fact (n-1) unused into let rec fact' n =
+ if n = 0 then 1
+ else n * fact' (n-1)
+ and fact n unused = fact' n
val separate_unused_arguments_in_set_of_closures :
+ Flambda.set_of_closures ->
+ backend:(module Backend_intf.S) ->
+ Flambda.set_of_closures optionRemove_unused_closure_varsval remove_unused_closure_variables :
+ remove_direct_call_surrogates:bool ->
+ Flambda.program ->
+ Flambda.programEliminate variables bound by sets of closures that are not required. Also eliminate functions within sets of closures that are not required.
Remove_unused_program_constructsval remove_unused_program_constructs : Flambda.program -> Flambda.programRuntimedefSchedgen.scheduler_genericmethod virtual oper_issue_cycles : Mach.operation -> intmethod virtual oper_latency : Mach.operation -> intmethod oper_in_basic_block : Mach.operation -> boolmethod is_store : Mach.operation -> boolmethod is_load : Mach.operation -> boolmethod is_checkbound : Mach.operation -> boolmethod schedule_fundecl : Linear.fundecl -> Linear.fundeclSchedgentype code_dag_node = {instr : Linear.instruction;delay : int;mutable sons : (code_dag_node * int) list;mutable date : int;mutable length : int;mutable ancestors : int;mutable emitted_ancestors : int;}class virtual scheduler_generic : object ... endSchedulingval fundecl : Linear.fundecl -> Linear.fundeclSelectgen.CoeffectSelectgen.EffectSelectgen.Effect_and_coeffectSelectgen.selector_genericmethod is_immediate : Mach.integer_operation -> int -> boolmethod virtual is_immediate_test : Mach.integer_comparison -> int -> boolmethod virtual select_addressing : Cmm.memory_chunk ->
+ Cmm.expression ->
+ Arch.addressing_mode * Cmm.expressionmethod is_simple_expr : Cmm.expression -> boolmethod effects_of : Cmm.expression -> Effect_and_coeffect.tmethod select_operation : Cmm.operation ->
+ Cmm.expression list ->
+ Debuginfo.t ->
+ Mach.operation * Cmm.expression listmethod select_condition : Cmm.expression -> Mach.test * Cmm.expressionmethod select_store : bool ->
+ Arch.addressing_mode ->
+ Cmm.expression ->
+ Mach.operation * Cmm.expressionmethod regs_for : Cmm.machtype -> Reg.t arraymethod insert_op : environment ->
+ Mach.operation ->
+ Reg.t array ->
+ Reg.t array ->
+ Reg.t arraymethod insert_op_debug : environment ->
+ Mach.operation ->
+ Debuginfo.t ->
+ Reg.t array ->
+ Reg.t array ->
+ Reg.t arraymethod insert_move_extcall_arg : environment ->
+ Cmm.exttype ->
+ Reg.t array ->
+ Reg.t array ->
+ unitmethod emit_extcall_args : environment ->
+ Cmm.exttype list ->
+ Cmm.expression list ->
+ Reg.t array * intmethod emit_stores : environment -> Cmm.expression list -> Reg.t array -> unitmethod mark_instr : Mach.instruction_desc -> unitmethod emit_fundecl : future_funcnames:Misc.Stdlib.String.Set.t ->
+ Cmm.fundecl ->
+ Mach.fundeclmethod extract_onto : Mach.instruction -> Mach.instructionmethod extract : Mach.instructionmethod insert : environment ->
+ Mach.instruction_desc ->
+ Reg.t array ->
+ Reg.t array ->
+ unitmethod insert_debug : environment ->
+ Mach.instruction_desc ->
+ Debuginfo.t ->
+ Reg.t array ->
+ Reg.t array ->
+ unitmethod insert_move : environment -> Reg.t -> Reg.t -> unitmethod insert_move_args : environment ->
+ Reg.t array ->
+ Reg.t array ->
+ int ->
+ unitmethod insert_move_results : environment ->
+ Reg.t array ->
+ Reg.t array ->
+ int ->
+ unitmethod insert_moves : environment -> Reg.t array -> Reg.t array -> unitmethod emit_expr : environment -> Cmm.expression -> Reg.t array optionmethod emit_tail : environment -> Cmm.expression -> unitval contains_calls : bool refSelectgenval env_add :
+ ?mut:Asttypes.mutable_flag ->
+ Backend_var.With_provenance.t ->
+ Reg.t array ->
+ environment ->
+ environmentval env_find : Backend_var.t -> environment -> Reg.t arrayval size_expr : environment -> Cmm.expression -> intmodule Effect : sig ... endmodule Coeffect : sig ... endmodule Effect_and_coeffect : sig ... endclass virtual selector_generic : object ... endSelectionval fundecl :
+ future_funcnames:Misc.Stdlib.String.Set.t ->
+ Cmm.fundecl ->
+ Mach.fundeclSemantics_of_primitivesDescription of the semantics of primitives, to be used for optimization purposes.
"No effects" means that the primitive does not change the observable state of the world. For example, it must not write to any mutable storage, call arbitrary external functions or change control flow (e.g. by raising an exception). Note that allocation is not "No effects" (see below).
It is assumed in the compiler that applications of primitives with no effects, whose results are not used, may be eliminated. It is further assumed that applications of primitives with no effects may be duplicated (and thus possibly executed more than once).
(Exceptions arising from allocation points, for example "out of memory" or exceptions propagated from finalizers or signal handlers, are treated as "effects out of the ether" and thus ignored for our determination here of effectfulness. The same goes for floating point operations that may cause hardware traps on some platforms.)
"Only generative effects" means that a primitive does not change the observable state of the world save for possibly affecting the state of the garbage collector by performing an allocation. Applications of primitives that only have generative effects and whose results are unused may be eliminated by the compiler. However, unlike "No effects" primitives, such applications will never be eligible for duplication.
"Arbitrary effects" covers all other primitives.
"No coeffects" means that the primitive does not observe the effects (in the sense described above) of other expressions. For example, it must not read from any mutable storage or call arbitrary external functions.
It is assumed in the compiler that, subject to data dependencies, expressions with neither effects nor coeffects may be reordered with respect to other expressions.
val for_primitive : Clambda_primitives.primitive -> effects * coeffectsDescribe the semantics of a primitive. This does not take into account of the (non-)(co)effectfulness of the arguments in a primitive application. To determine whether such an application is (co)effectful, the arguments must also be analysed.
val return_type_of_primitive : Clambda_primitives.primitive -> return_typeSemaphore.Binaryval make : bool -> tmake b returns a new binary semaphore. If b is true, the initial value of the semaphore is 1, meaning "available". If b is false, the initial value of the semaphore is 0, meaning "unavailable".
val release : t -> unitrelease s sets the value of semaphore s to 1, putting it in the "available" state. If other threads are waiting on s, one of them is restarted.
val acquire : t -> unitacquire s blocks the calling thread until the semaphore s has value 1 (is available), then atomically sets it to 0 and returns.
val try_acquire : t -> booltry_acquire s immediately returns false if the semaphore s has value 0. If s has value 1, its value is atomically set to 0 and try_acquire s returns true.
Semaphore.Countingval make : int -> tmake n returns a new counting semaphore, with initial value n. The initial value n must be nonnegative.
val release : t -> unitrelease s increments the value of semaphore s. If other threads are waiting on s, one of them is restarted. If the current value of s is equal to max_int, the value of the semaphore is unchanged and a Sys_error exception is raised to signal overflow.
val acquire : t -> unitacquire s blocks the calling thread until the value of semaphore s is not zero, then atomically decrements the value of s and returns.
val try_acquire : t -> booltry_acquire s immediately returns false if the value of semaphore s is zero. Otherwise, the value of s is atomically decremented and try_acquire s returns true.
SemaphoreSemaphores
A semaphore is a thread synchronization device that can be used to control access to a shared resource.
Two flavors of semaphores are provided: counting semaphores and binary semaphores.
A counting semaphore is a counter that can be accessed concurrently by several threads. The typical use is to synchronize producers and consumers of a resource by counting how many units of the resource are available.
The two basic operations on semaphores are:
module Counting : sig ... endBinary semaphores are a variant of counting semaphores where semaphores can only take two values, 0 and 1.
A binary semaphore can be used to control access to a single shared resource, with value 1 meaning "resource is available" and value 0 meaning "resource is unavailable".
The "release" operation of a binary semaphore sets its value to 1, and "acquire" waits until the value is 1 and sets it to 0.
A binary semaphore can be used instead of a mutex (see module Mutex) when the mutex discipline (of unlocking the mutex from the thread that locked it) is too restrictive. The "acquire" operation corresponds to locking the mutex, and the "release" operation to unlocking it, but "release" can be performed in a thread different than the one that performed the "acquire". Likewise, it is safe to release a binary semaphore that is already available.
module Binary : sig ... endSet_of_closures_id.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitSet_of_closures_id.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringSet_of_closures_id.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitSet_of_closures_id.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tSet_of_closures_idAn identifier, unique across the whole program, that identifies a set of closures (viz. Set_of_closures).
include Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create : ?name:string -> Compilation_unit.t -> tval name : t -> string optionval get_compilation_unit : t -> Compilation_unit.tSet_of_closures_origin.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitSet_of_closures_origin.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringSet_of_closures_origin.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitSet_of_closures_origin.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tSet_of_closures_origininclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create : Set_of_closures_id.t -> tval get_compilation_unit : t -> Compilation_unit.tval rename : (Set_of_closures_id.t -> Set_of_closures_id.t) -> t -> tItem.Maptype key = tThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Shape.Itemval make : string -> Sig_component_kind.t -> tMake_reduce.Contextval read_unit_shape : unit_name:string -> t optionShape.Make_reduceThe Make_reduce functor is used to generate a reduction function for shapes.
It is parametrized by:
Shape.MapShape.Sig_component_kindval to_string : t -> stringval can_appear_in_types : t -> boolWhether the name of a component of that kind can appear in a type.
Uid.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitUid.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringUid.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitUid.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tShape.Uidval mk : current_unit:string -> tval internal_not_actually_unique : tval for_actual_declaration : t -> boolinclude Identifiable.S with type t := tmodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := TShapemodule Uid : sig ... endmodule Sig_component_kind : sig ... endmodule Item : sig ... endtype var = Ident.tval print : Stdlib.Format.formatter -> t -> unitval for_unnamed_functor_param : varval str : ?uid:Uid.t -> t Item.Map.t -> tval for_persistent_unit : string -> tval leaf_for_unpack : tmodule Map : sig ... endval dummy_mod : tval of_path :
+ find_shape:(Sig_component_kind.t -> Ident.t -> t) ->
+ namespace:Sig_component_kind.t ->
+ Path.t ->
+ tmodule Make_reduce (Context : sig ... end) : sig ... endThe Make_reduce functor is used to generate a reduction function for shapes.
Share_constantsShare lifted constants that are eligible for sharing (e.g. not strings) and have equal definitions.
Signature_groupIterate on signature by syntactic group of items
Classes, class types and private row types adds ghost components to the signature where they are defined.
When editing or printing a signature it is therefore important to identify those ghost components.
This module provides type grouping together ghost components with the corresponding core item (or recursive group) and the corresponding iterators.
type sig_item = {src : Types.signature_item;the syntactic item
*)post_ghosts : Types.signature_item list;ghost classes types are post-declared
*)}Classes and class types generate ghosts signature items, we group them together before printing
val flatten : sig_item -> Types.signatureflatten sig_item is x.src :: x.post_ghosts
A group of mutually recursive definition
val rec_items : core_rec_group -> sig_item listrec_items group is the list of sig_items in the group
Private #row types are manifested as a sequence of definitions preceding a recursive group, we collect them and separate them from the syntactic recursive group.
val next : Types.signature -> (rec_group * Types.signature) optionval seq : Types.signature -> rec_group Stdlib.Seq.tval iter : (rec_group -> unit) -> Types.signature -> unitval fold : ('acc -> rec_group -> 'acc) -> 'acc -> Types.signature -> 'acctype in_place_patch = {ghosts : Types.signature;updated list of ghost items
*)replace_by : Types.signature_item option;replacement for the selected item
*)}Describe how to amend one element of a signature
val replace_in_place :
+ (ghosts:Types.signature ->
+ Types.signature_item ->
+ ('a * in_place_patch) option) ->
+ Types.signature ->
+ ('a * Types.signature) option!replace_in_place patch sg replaces the first element of the signature for which patch ~rec_group ~ghosts component returns Some (value,patch). The rec_group argument is the remaining part of the mutually recursive group of component. The ghosts list is the current prefix of ghost components associated to component
Simple_value_approxSimple approximations to the runtime results of computations. This pass is designed for speed rather than accuracy; the performance is important since it is used heavily during inlining.
A value of type t corresponds to an "approximation" of the result of a computation in the program being compiled. That is to say, it represents what knowledge we have about such a result at compile time. The simplification pass exploits this information to partially evaluate computations.
At a high level, an approximation for a value v has three parts:
v.The exact semantics of the variable and symbol fields follows.
Approximations are deduced at particular points in an expression tree, but may subsequently be propagated to other locations.
At the point at which an approximation is built for some value v, we can construct a set of variables (call the set S) that are known to alias the same value v. Each member of S will have the same or a more precise descr field in its approximation relative to the approximation for v. (An increase in precision may currently be introduced for pattern matches.) If S is non-empty then it is guaranteed that there is a unique member of S that was declared in a scope further out ("earlier") than all other members of S. If such a member exists then it is recorded in the var field. Otherwise var is None.
Analogous to the construction of the set S, we can construct a set T consisting of all symbols that are known to alias the value whose approximation is being constructed. If T is non-empty then the symbol field is set to some member of T; it does not matter which one. (There is no notion of scope for symbols.)
Note about mutable blocks:
Mutable blocks are always represented by Value_unknown or Value_bottom. Any other approximation could leave the door open to a miscompilation. Such bad scenarios are most likely a user using Obj.magic or Obj.set_field in an inappropriate situation. Such a situation might be: let x = (1, 1) in
+ Obj.set_field (Obj.repr x) 0 (Obj.repr 2);
+ assert(fst x = 2) The user would probably expect the assertion to be true, but the compiler could in fact propagate the value of x across the Obj.set_field.
Insisting that mutable blocks have Value_unknown or Value_bottom approximations certainly won't always prevent this kind of error, but should help catch many of them.
It is possible that there may be some false positives, with correct but unreachable code causing this check to fail. However the likelihood of this seems sufficiently low, especially compared to the advantages gained by performing the check, that we include it.
An example of a pattern that might trigger a false positive is: type a = { a : int }
+ type b = { mutable b : int }
+ type _ t =
+ | A : a t
+ | B : b t
+ let f (type x) (v:x t) (r:x) =
+ match v with
+ | A -> r.a
+ | B -> r.b <- 2; 3
+ let v =
+ let r =
+ ref A in
+ r := A; (* Some pattern that the compiler can't understand *)
+ f !r { a = 1 } When inlining f, the B branch is unreachable, yet the compiler cannot prove it and must therefore keep it.
and descr = private | Value_block of Tag.t * t array| Value_int of int| Value_char of char| Value_float of float option| Value_boxed_int : 'a boxed_int * 'a -> descr| Value_set_of_closures of value_set_of_closures| Value_closure of value_closure| Value_string of value_string| Value_float_array of value_float_array| Value_unknown of unknown_because_of| Value_bottom| Value_extern of Export_id.t| Value_symbol of Symbol.t| Value_unresolved of unresolved_valueand function_declarations = private {is_classic_mode : bool;set_of_closures_id : Set_of_closures_id.t;set_of_closures_origin : Set_of_closures_origin.t;funs : function_declaration Variable.Map.t;}and function_body = private {free_variables : Variable.Set.t;free_symbols : Symbol.Set.t;stub : bool;dbg : Debuginfo.t;inline : Lambda.inline_attribute;specialise : Lambda.specialise_attribute;is_a_functor : bool;body : Flambda.t;poll : Lambda.poll_attribute;}and function_declaration = private {closure_origin : Closure_origin.t;params : Parameter.t list;function_body : function_body option;}and value_set_of_closures = private {function_decls : function_declarations;bound_vars : t Var_within_closure.Map.t;free_vars : Flambda.specialised_to Variable.Map.t;invariant_params : Variable.Set.t Variable.Map.t Stdlib.Lazy.t;recursive : Variable.Set.t Stdlib.Lazy.t;size : int option Variable.Map.t Stdlib.Lazy.t;For functions that are very likely to be inlined, the size of the function's body.
*)specialised_args : Flambda.specialised_to Variable.Map.t;freshening : Freshening.Project_var.t;direct_call_surrogates : Closure_id.t Closure_id.Map.t;}val print : Stdlib.Format.formatter -> t -> unitPretty-printing of approximations to a formatter.
val print_descr : Stdlib.Format.formatter -> descr -> unitval print_value_set_of_closures :
+ Stdlib.Format.formatter ->
+ value_set_of_closures ->
+ unitval print_function_declarations :
+ Stdlib.Format.formatter ->
+ function_declarations ->
+ unitval function_declarations_approx :
+ keep_body:(Variable.t -> Flambda.function_declaration -> bool) ->
+ Flambda.function_declarations ->
+ function_declarationsval create_value_set_of_closures :
+ function_decls:function_declarations ->
+ bound_vars:t Var_within_closure.Map.t ->
+ free_vars:Flambda.specialised_to Variable.Map.t ->
+ invariant_params:Variable.Set.t Variable.Map.t lazy_t ->
+ recursive:Variable.Set.t Stdlib.Lazy.t ->
+ specialised_args:Flambda.specialised_to Variable.Map.t ->
+ freshening:Freshening.Project_var.t ->
+ direct_call_surrogates:Closure_id.t Closure_id.Map.t ->
+ value_set_of_closuresval update_freshening_of_value_set_of_closures :
+ value_set_of_closures ->
+ freshening:Freshening.Project_var.t ->
+ value_set_of_closuresval value_unknown : unknown_because_of -> tBasic construction of approximations.
val value_int : int -> tval value_char : char -> tval value_float : float -> tval value_any_float : tval value_mutable_float_array : size:int -> tval value_string : int -> string option -> tval value_extern : Export_id.t -> tval value_bottom : tval value_unresolved : unresolved_value -> tval value_closure :
+ ?closure_var:Variable.t ->
+ ?set_of_closures_var:Variable.t ->
+ ?set_of_closures_symbol:Symbol.t ->
+ value_set_of_closures ->
+ Closure_id.t ->
+ tConstruct a closure approximation given the approximation of the corresponding set of closures and the closure ID of the closure to be projected from such set. closure_var and/or set_of_closures_var may be specified to augment the approximation with variables that may be used to access the closure value itself, so long as they are in scope at the proposed point of use.
val value_set_of_closures :
+ ?set_of_closures_var:Variable.t ->
+ value_set_of_closures ->
+ tConstruct a set of closures approximation. set_of_closures_var is as for the parameter of the same name in value_closure, above.
Take the given constant and produce an appropriate approximation for it together with an Flambda expression representing it.
val make_const_int_named : int -> Flambda.named * tval make_const_char_named : char -> Flambda.named * tval make_const_bool_named : bool -> Flambda.named * tval make_const_float_named : float -> Flambda.named * tval make_const_boxed_int_named : 'i boxed_int -> 'i -> Flambda.named * tval augment_with_variable : t -> Variable.t -> tAugment an approximation with a given variable (see comment above). If the approximation was already augmented with a variable, the one passed to this function replaces it within the approximation.
Like augment_with_symbol, but for symbol field information.
val augment_with_kind : t -> Lambda.value_kind -> tImprove the description by taking the kind into account
val augment_kind_with_approx : t -> Lambda.value_kind -> Lambda.value_kindImprove the kind by taking the description into account
val known : t -> boolAn approximation is "known" iff it is not Value_unknown.
val useful : t -> boolAn approximation is "useful" iff it is neither unknown nor bottom.
val all_not_useful : t list -> boolWhether all approximations in the given list do *not* satisfy useful.
val warn_on_mutation : t -> boolWhether to warn on attempts to mutate a value. It must have been resolved (it cannot be Value_extern or Value_symbol). (See comment above for further explanation.)
type simplification_result = Flambda.t * simplification_summary * ttype simplification_result_named = Flambda.named * simplification_summary * tval simplify : t -> Flambda.t -> simplification_resultGiven an expression and its approximation, attempt to simplify the expression to a constant (with associated approximation), taking into account whether the expression has any side effects.
val simplify_using_env :
+ t ->
+ is_present_in_env:(Variable.t -> bool) ->
+ Flambda.t ->
+ simplification_resultAs for simplify, but also enables us to simplify based on equalities between variables. The caller must provide a function that tells us whether, if we simplify to a given variable, the value of that variable will be accessible in the current environment.
val simplify_named : t -> Flambda.named -> simplification_result_namedval simplify_named_using_env :
+ t ->
+ is_present_in_env:(Variable.t -> bool) ->
+ Flambda.named ->
+ simplification_result_namedval simplify_var_to_var_using_env :
+ t ->
+ is_present_in_env:(Variable.t -> bool) ->
+ Variable.t optionIf the given approximation identifies another variable and is_present_in_env deems it to be in scope, return that variable (wrapped in a Some), otherwise return None.
val simplify_var : t -> (Flambda.named * t) optionval get_field : t -> field_index:int -> get_field_resultGiven the approximation t of a value, expected to correspond to a block (in the Pmakeblock sense of the word), and a field index then return an appropriate approximation for that field of the block (or Unreachable if the code with the approximation t is unreachable). N.B. Not all cases of unreachable code are returned as Unreachable.
val check_approx_for_block : t -> checked_approx_for_blockTry to prove that a value with the given approximation may be used as a block.
val approx_for_bound_var : value_set_of_closures -> Var_within_closure.t -> tFind the approximation for a bound variable in a set-of-closures approximation. A fatal error is produced if the variable is not bound in the given approximation.
val freshen_and_check_closure_id :
+ value_set_of_closures ->
+ Closure_id.t ->
+ Closure_id.tGiven a set-of-closures approximation and a closure ID, apply any freshening specified by the approximation to the closure ID, and return the resulting ID. Causes a fatal error if the resulting closure ID does not correspond to any function declaration in the approximation.
type strict_checked_approx_for_set_of_closures = | Wrong| Ok of Variable.t option * value_set_of_closuresval strict_check_approx_for_set_of_closures :
+ t ->
+ strict_checked_approx_for_set_of_closurestype checked_approx_for_set_of_closures = | Wrong| Unresolved of unresolved_value| Unknown| Unknown_because_of_unresolved_value of unresolved_value| Ok of Variable.t option * value_set_of_closuresval check_approx_for_set_of_closures : t -> checked_approx_for_set_of_closuresTry to prove that a value with the given approximation may be used as a set of closures. Values coming from external compilation units with unresolved approximations are permitted.
type checked_approx_for_closure = | Wrong| Ok of value_closure
+ * Variable.t option
+ * Symbol.t option
+ * value_set_of_closuresval check_approx_for_closure : t -> checked_approx_for_closureTry to prove that a value with the given approximation may be used as a closure. Values coming from external compilation units with unresolved approximations are not permitted.
type checked_approx_for_closure_allowing_unresolved = | Wrong| Unresolved of unresolved_value| Unknown| Unknown_because_of_unresolved_value of unresolved_value| Ok of value_closure
+ * Variable.t option
+ * Symbol.t option
+ * value_set_of_closuresval check_approx_for_closure_allowing_unresolved :
+ t ->
+ checked_approx_for_closure_allowing_unresolvedAs for check_approx_for_closure, but values coming from external compilation units with unresolved approximations are permitted.
val check_approx_for_float : t -> float optionReturns the value if it can be proved to be a constant float
val float_array_as_constant : value_float_array -> float list optionReturns the value if it can be proved to be a constant float array
val check_approx_for_string : t -> string optionReturns the value if it can be proved to be a constant string
val potentially_taken_const_switch_branch : t -> int -> switch_branch_selectionCheck that the branch is compatible with the approximation
val potentially_taken_block_switch_branch : t -> int -> switch_branch_selectionval function_arity : function_declaration -> intval update_function_declarations :
+ function_declarations ->
+ funs:function_declaration Variable.Map.t ->
+ function_declarationsCreate a set of function declarations based on another set of function declarations.
val import_function_declarations_for_pack :
+ function_declarations ->
+ (Set_of_closures_id.t -> Set_of_closures_id.t) ->
+ (Set_of_closures_origin.t -> Set_of_closures_origin.t) ->
+ function_declarationsval update_function_declaration_body :
+ function_declaration ->
+ (Flambda.t -> Flambda.t) ->
+ function_declarationval make_closure_map :
+ function_declarations Set_of_closures_id.Map.t ->
+ function_declarations Closure_id.Map.tCreates a map from closure IDs to function declarations by iterating over all sets of closures in the given map.
val clear_function_bodies : function_declarations -> function_declarationsSimplifLambda simplification.
Warning: this module is unstable and part of compiler-libs.
val simplify_lambda : Lambda.lambda -> Lambda.lambdaval split_default_wrapper :
+ id:Ident.t ->
+ kind:Lambda.function_kind ->
+ params:(Ident.t * Lambda.value_kind) list ->
+ return:Lambda.value_kind ->
+ body:Lambda.lambda ->
+ attr:Lambda.function_attribute ->
+ loc:Lambda.scoped_location ->
+ (Ident.t * Lambda.lambda) listSimplify_boxed_integer_ops.Simplify_boxed_int32val simplify_unop :
+ Clambda_primitives.primitive ->
+ Stdlib.Int32.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Int32.t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop :
+ Clambda_primitives.primitive ->
+ Stdlib.Int32.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Int32.t ->
+ Stdlib.Int32.t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop_int :
+ Clambda_primitives.primitive ->
+ Stdlib.Int32.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Int32.t ->
+ int ->
+ size_int:int ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tSimplify_boxed_integer_ops.Simplify_boxed_int64val simplify_unop :
+ Clambda_primitives.primitive ->
+ Stdlib.Int64.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Int64.t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop :
+ Clambda_primitives.primitive ->
+ Stdlib.Int64.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Int64.t ->
+ Stdlib.Int64.t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop_int :
+ Clambda_primitives.primitive ->
+ Stdlib.Int64.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Int64.t ->
+ int ->
+ size_int:int ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tSimplify_boxed_integer_ops.Simplify_boxed_nativeintval simplify_unop :
+ Clambda_primitives.primitive ->
+ Stdlib.Nativeint.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Nativeint.t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop :
+ Clambda_primitives.primitive ->
+ Stdlib.Nativeint.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Nativeint.t ->
+ Stdlib.Nativeint.t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop_int :
+ Clambda_primitives.primitive ->
+ Stdlib.Nativeint.t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ Stdlib.Nativeint.t ->
+ int ->
+ size_int:int ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tSimplify_boxed_integer_opsmodule Simplify_boxed_nativeint :
+ Simplify_boxed_integer_ops_intf.S with type t := Stdlib.Nativeint.tmodule Simplify_boxed_int32 :
+ Simplify_boxed_integer_ops_intf.S with type t := Stdlib.Int32.tmodule Simplify_boxed_int64 :
+ Simplify_boxed_integer_ops_intf.S with type t := Stdlib.Int64.tSimplify_boxed_integer_ops_intfmodule type S = sig ... endSimplify_boxed_integer_ops_intf.Sval simplify_unop :
+ Clambda_primitives.primitive ->
+ t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop :
+ Clambda_primitives.primitive ->
+ t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ t ->
+ t ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval simplify_binop_int :
+ Clambda_primitives.primitive ->
+ t Simple_value_approx.boxed_int ->
+ Flambda.named ->
+ t ->
+ int ->
+ size_int:int ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tSimplify_commonconst_*_expr expr v annot, where the expression expr is known to evaluate to the value v, attempt to produce a more simple expression together with its approximation and the benefit gained by replacing expr with this new expression. This simplification is only performed if expr is known to have no side effects. Otherwise, expr itself is returned, with an appropriate approximation but zero benefit.
const_boxed_int_expr takes an additional argument specifying the kind of boxed integer to which the given expression evaluates.
val const_int_expr :
+ Flambda.named ->
+ int ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval const_char_expr :
+ Flambda.named ->
+ char ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval const_bool_expr :
+ Flambda.named ->
+ bool ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval const_float_expr :
+ Flambda.named ->
+ float ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval const_boxed_int_expr :
+ Flambda.named ->
+ 'a Simple_value_approx.boxed_int ->
+ 'a ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval const_integer_comparison_expr :
+ Flambda.named ->
+ Lambda.integer_comparison ->
+ 'a ->
+ 'a ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tval const_float_comparison_expr :
+ Flambda.named ->
+ Lambda.float_comparison ->
+ float ->
+ float ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tSimplify_primitivesval primitive :
+ Clambda_primitives.primitive ->
+ (Variable.t list * Simple_value_approx.t list) ->
+ Flambda.named ->
+ Debuginfo.t ->
+ size_int:int ->
+ Flambda.named * Simple_value_approx.t * Inlining_cost.Benefit.tSimplifies an application of a primitive based on approximation information.
Spillval fundecl : Mach.fundecl -> Mach.fundeclSplitval fundecl : Mach.fundecl -> Mach.fundeclStatic_exception.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitStatic_exception.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringStatic_exception.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitStatic_exception.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tStatic_exceptionAn identifier that is used to label static exceptions. Its uniqueness properties are unspecified.
include Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create : unit -> tval to_int : t -> intStd_exitStdlib.ArgParsing of command line arguments.
This module provides a general mechanism for extracting options and arguments from the command line to the program. For example:
let usage_msg = "append [-verbose] <file1> [<file2>] ... -o <output>"
+let verbose = ref false
+let input_files = ref []
+let output_file = ref ""
+
+let anon_fun filename =
+ input_files := filename::!input_files
+
+let speclist =
+ [("-verbose", Arg.Set verbose, "Output debug information");
+ ("-o", Arg.Set_string output_file, "Set output file name")]
+
+let () =
+ Arg.parse speclist anon_fun usage_msg;
+ (* Main functionality here *)Syntax of command lines: A keyword is a character string starting with a -. An option is a keyword alone or followed by an argument. The types of keywords are: Unit, Bool, Set, Clear, String, Set_string, Int, Set_int, Float, Set_float, Tuple, Symbol, Rest, Rest_all and Expand.
Unit, Set and Clear keywords take no argument.
A Rest or Rest_all keyword takes the remainder of the command line as arguments. (More explanations below.)
Every other keyword takes the following word on the command line as argument. For compatibility with GNU getopt_long, keyword=arg is also allowed. Arguments not preceded by a keyword are called anonymous arguments.
Examples (cmd is assumed to be the command name):
cmd -flag (a unit option)cmd -int 1 (an int option with argument 1)cmd -string foobar (a string option with argument "foobar")cmd -float 12.34 (a float option with argument 12.34)cmd a b c (three anonymous arguments: "a", "b", and "c")cmd a b -- c d (two anonymous arguments and a rest option with two arguments)Rest takes a function that is called repeatedly for each remaining command line argument. Rest_all takes a function that is called once, with the list of all remaining arguments.
Note that if no arguments follow a Rest keyword then the function is not called at all whereas the function for a Rest_all keyword is called with an empty list.
type spec = | Unit of unit -> unitCall the function with unit argument
*)| Bool of bool -> unitCall the function with a bool argument
*)| Set of bool refSet the reference to true
*)| Clear of bool refSet the reference to false
*)| String of string -> unitCall the function with a string argument
*)| Set_string of string refSet the reference to the string argument
*)| Int of int -> unitCall the function with an int argument
*)| Set_int of int refSet the reference to the int argument
*)| Float of float -> unitCall the function with a float argument
*)| Set_float of float refSet the reference to the float argument
*)| Tuple of spec listTake several arguments according to the spec list
*)| Symbol of string list * string -> unitTake one of the symbols as argument and call the function with the symbol
*)| Rest of string -> unitStop interpreting keywords and call the function with each remaining argument
*)| Rest_all of string list -> unitStop interpreting keywords and call the function with all remaining arguments
*)| Expand of string -> string arrayIf the remaining arguments to process are of the form ["-foo"; "arg"] @ rest where "foo" is registered as Expand f, then the arguments f "arg" @ rest are processed. Only allowed in parse_and_expand_argv_dynamic.
The concrete type describing the behavior associated with a keyword.
Arg.parse speclist anon_fun usage_msg parses the command line. speclist is a list of triples (key, spec, doc). key is the option keyword, it must start with a '-' character. spec gives the option type and the function to call when this option is found on the command line. doc is a one-line description of this option. anon_fun is called on anonymous arguments. The functions in spec and anon_fun are called in the same order as their arguments appear on the command line.
If an error occurs, Arg.parse exits the program, after printing to standard error an error message as follows:
usage_msgdoc string. Beware: options that have an empty doc string will not be included in the list.For the user to be able to specify anonymous arguments starting with a -, include for example ("-", String anon_fun, doc) in speclist.
By default, parse recognizes two unit options, -help and --help, which will print to standard output usage_msg and the list of options, and exit the program. You can override this behaviour by specifying your own -help and --help options in speclist.
Same as Arg.parse, except that the speclist argument is a reference and may be updated during the parsing. A typical use for this feature is to parse command lines of the form:
options where the list of options depends on the value of the subcommand argument.val parse_argv :
+ ?current:int ref ->
+ string array ->
+ (key * spec * doc) list ->
+ anon_fun ->
+ usage_msg ->
+ unitArg.parse_argv ~current args speclist anon_fun usage_msg parses the array args as if it were the command line. It uses and updates the value of ~current (if given), or Arg.current. You must set it before calling parse_argv. The initial value of current is the index of the program name (argument 0) in the array. If an error occurs, Arg.parse_argv raises Arg.Bad with the error message as argument. If option -help or --help is given, Arg.parse_argv raises Arg.Help with the help message as argument.
val parse_argv_dynamic :
+ ?current:int ref ->
+ string array ->
+ (key * spec * doc) list ref ->
+ anon_fun ->
+ string ->
+ unitSame as Arg.parse_argv, except that the speclist argument is a reference and may be updated during the parsing. See Arg.parse_dynamic.
val parse_and_expand_argv_dynamic :
+ int ref ->
+ string array ref ->
+ (key * spec * doc) list ref ->
+ anon_fun ->
+ string ->
+ unitSame as Arg.parse_argv_dynamic, except that the argv argument is a reference and may be updated during the parsing of Expand arguments. See Arg.parse_argv_dynamic.
Functions in spec or anon_fun can raise Arg.Bad with an error message to reject invalid arguments. Arg.Bad is also raised by Arg.parse_argv in case of an error.
Returns the message that would have been printed by Arg.usage, if provided with the same parameters.
Align the documentation strings by inserting spaces at the first alignment separator (tab or, if tab is not found, space), according to the length of the keyword. Use a alignment separator as the first character in a doc string if you want to align the whole string. The doc strings corresponding to Symbol arguments are aligned on the next line.
val current : int refPosition (in Sys.argv) of the argument being processed. You can change this value, e.g. to force Arg.parse to skip some arguments. Arg.parse uses the initial value of Arg.current as the index of argument 0 (the program name) and starts parsing arguments at the next element.
Arg.read_arg file reads newline-terminated command line arguments from file file.
Identical to Arg.read_arg but assumes null character terminated command line arguments.
Arg.write_arg file args writes the arguments args newline-terminated into the file file. If the any of the arguments in args contains a newline, use Arg.write_arg0 instead.
Identical to Arg.write_arg but uses the null character for terminator instead of newline.
Stdlib.ArrayArray operations.
The labeled version of this module can be used as described in the StdLabels module.
get a n returns the element number n of array a. The first element has number 0. The last element has number length a - 1. You can also write a.(n) instead of get a n.
set a n x modifies array a in place, replacing element number n with x. You can also write a.(n) <- x instead of set a n x.
make n x returns a fresh array of length n, initialized with x. All the elements of this new array are initially physically equal to x (in the sense of the == predicate). Consequently, if x is mutable, it is shared among all elements of the array, and modifying x through one of the array entries will modify all other entries at the same time.
create_float n returns a fresh float array of length n, with uninitialized data.
init n f returns a fresh array of length n, with element number i initialized to the result of f i. In other terms, init n f tabulates the results of f applied to the integers 0 to n-1.
make_matrix dimx dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy. All the elements of this new matrix are initially physically equal to e. The element (x,y) of a matrix m is accessed with the notation m.(x).(y).
append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
Same as append, but concatenates a list of arrays.
sub a pos len returns a fresh array of length len, containing the elements number pos to pos + len - 1 of array a.
copy a returns a copy of a, that is, a fresh array containing the same elements as a.
fill a pos len x modifies the array a in place, storing x in elements number pos to pos + len - 1.
blit src src_pos dst dst_pos len copies len elements from array src, starting at element number src_pos, to array dst, starting at element number dst_pos. It works correctly even if src and dst are the same array, and the source and destination chunks overlap.
iter f a applies function f in turn to all the elements of a. It is equivalent to f a.(0); f a.(1); ...; f a.(length a - 1); ().
Same as iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.
map f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].
Same as map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
fold_left f init a computes f (... (f (f init a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.
fold_right f a init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the array a.
iter2 f a b applies function f to all the elements of a and b.
map2 f a b applies function f to all the elements of a and b, and builds an array with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
for_all f [|a1; ...; an|] checks if all elements of the array satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an).
exists f [|a1; ...; an|] checks if at least one element of the array satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an).
Same as for_all, but for a two-argument predicate.
Same as exists, but for a two-argument predicate.
mem a set is true if and only if a is structurally equal to an element of l (i.e. there is an x in l such that compare a x = 0).
Same as mem, but uses physical equality instead of structural equality to compare list elements.
find_opt f a returns the first element of the array a that satisfies the predicate f, or None if there is no value that satisfies f in the array a.
find_map f a applies f to the elements of a in order, and returns the first result of the form Some v, or None if none exist.
split [|(a1,b1); ...; (an,bn)|] is ([|a1; ...; an|], [|b1; ...; bn|]).
combine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|]. Raise Invalid_argument if the two arrays have different lengths.
Sort an array in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see below for a complete specification). For example, Stdlib.compare is a suitable comparison function. After calling sort, the array is sorted in place in increasing order. sort is guaranteed to run in constant heap space and (at most) logarithmic stack space.
The current implementation uses Heap Sort. It runs in constant stack space.
Specification of the comparison function: Let a be the array and cmp the comparison function. The following must be true for all x, y, z in a :
cmp x y > 0 if and only if cmp y x < 0cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0When sort returns, a contains the same elements as before, reordered in such a way that for all i and j valid indices of a :
cmp a.(i) a.(j) >= 0 if and only if i >= jSame as sort, but the sorting algorithm is stable (i.e. elements that compare equal are kept in their original order) and not guaranteed to run in constant heap space.
The current implementation uses Merge Sort. It uses a temporary array of length n/2, where n is the length of the array. It is usually faster than the current implementation of sort.
Same as sort or stable_sort, whichever is faster on typical input.
val to_seq : 'a array -> 'a Seq.tIterate on the array, in increasing order. Modifications of the array during iteration will be reflected in the sequence.
val to_seqi : 'a array -> (int * 'a) Seq.tIterate on the array, in increasing order, yielding indices along elements. Modifications of the array during iteration will be reflected in the sequence.
val of_seq : 'a Seq.t -> 'a arrayCreate an array from the generator
Stdlib.ArrayLabelsArray operations.
The labeled version of this module can be used as described in the StdLabels module.
get a n returns the element number n of array a. The first element has number 0. The last element has number length a - 1. You can also write a.(n) instead of get a n.
set a n x modifies array a in place, replacing element number n with x. You can also write a.(n) <- x instead of set a n x.
make n x returns a fresh array of length n, initialized with x. All the elements of this new array are initially physically equal to x (in the sense of the == predicate). Consequently, if x is mutable, it is shared among all elements of the array, and modifying x through one of the array entries will modify all other entries at the same time.
create_float n returns a fresh float array of length n, with uninitialized data.
init n ~f returns a fresh array of length n, with element number i initialized to the result of f i. In other terms, init n ~f tabulates the results of f applied to the integers 0 to n-1.
make_matrix ~dimx ~dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy. All the elements of this new matrix are initially physically equal to e. The element (x,y) of a matrix m is accessed with the notation m.(x).(y).
append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
Same as append, but concatenates a list of arrays.
sub a ~pos ~len returns a fresh array of length len, containing the elements number pos to pos + len - 1 of array a.
copy a returns a copy of a, that is, a fresh array containing the same elements as a.
fill a ~pos ~len x modifies the array a in place, storing x in elements number pos to pos + len - 1.
val blit :
+ src:'a array ->
+ src_pos:int ->
+ dst:'a array ->
+ dst_pos:int ->
+ len:int ->
+ unitblit ~src ~src_pos ~dst ~dst_pos ~len copies len elements from array src, starting at element number src_pos, to array dst, starting at element number dst_pos. It works correctly even if src and dst are the same array, and the source and destination chunks overlap.
iter ~f a applies function f in turn to all the elements of a. It is equivalent to f a.(0); f a.(1); ...; f a.(length a - 1); ().
Same as iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.
map ~f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].
Same as map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
fold_left ~f ~init a computes f (... (f (f init a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.
fold_right ~f a ~init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the array a.
iter2 ~f a b applies function f to all the elements of a and b.
map2 ~f a b applies function f to all the elements of a and b, and builds an array with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
for_all ~f [|a1; ...; an|] checks if all elements of the array satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an).
exists ~f [|a1; ...; an|] checks if at least one element of the array satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an).
Same as for_all, but for a two-argument predicate.
Same as exists, but for a two-argument predicate.
mem a ~set is true if and only if a is structurally equal to an element of l (i.e. there is an x in l such that compare a x = 0).
Same as mem, but uses physical equality instead of structural equality to compare list elements.
find_opt ~f a returns the first element of the array a that satisfies the predicate f, or None if there is no value that satisfies f in the array a.
find_map ~f a applies f to the elements of a in order, and returns the first result of the form Some v, or None if none exist.
split [|(a1,b1); ...; (an,bn)|] is ([|a1; ...; an|], [|b1; ...; bn|]).
combine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|]. Raise Invalid_argument if the two arrays have different lengths.
Sort an array in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see below for a complete specification). For example, Stdlib.compare is a suitable comparison function. After calling sort, the array is sorted in place in increasing order. sort is guaranteed to run in constant heap space and (at most) logarithmic stack space.
The current implementation uses Heap Sort. It runs in constant stack space.
Specification of the comparison function: Let a be the array and cmp the comparison function. The following must be true for all x, y, z in a :
cmp x y > 0 if and only if cmp y x < 0cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0When sort returns, a contains the same elements as before, reordered in such a way that for all i and j valid indices of a :
cmp a.(i) a.(j) >= 0 if and only if i >= jSame as sort, but the sorting algorithm is stable (i.e. elements that compare equal are kept in their original order) and not guaranteed to run in constant heap space.
The current implementation uses Merge Sort. It uses a temporary array of length n/2, where n is the length of the array. It is usually faster than the current implementation of sort.
Same as sort or stable_sort, whichever is faster on typical input.
val to_seq : 'a array -> 'a Seq.tIterate on the array, in increasing order. Modifications of the array during iteration will be reflected in the sequence.
val to_seqi : 'a array -> (int * 'a) Seq.tIterate on the array, in increasing order, yielding indices along elements. Modifications of the array during iteration will be reflected in the sequence.
val of_seq : 'a Seq.t -> 'a arrayCreate an array from the generator
Stdlib.AtomicThis module provides a purely sequential implementation of the concurrent atomic references provided by the Multicore OCaml standard library:
https://github.com/ocaml-multicore/ocaml-multicore/blob/parallel_minor_gc/stdlib/atomic.mli
This sequential implementation is provided in the interest of compatibility: when people will start writing code to run on Multicore, it would be nice if their use of Atomic was backward-compatible with older versions of OCaml without having to import additional compatibility layers.
val make : 'a -> 'a tCreate an atomic reference.
val get : 'a t -> 'aGet the current value of the atomic reference.
val set : 'a t -> 'a -> unitSet a new value for the atomic reference.
val exchange : 'a t -> 'a -> 'aSet a new value for the atomic reference, and return the current value.
val compare_and_set : 'a t -> 'a -> 'a -> boolcompare_and_set r seen v sets the new value of r to v only if its current value is physically equal to seen -- the comparison and the set occur atomically. Returns true if the comparison succeeded (so the set happened) and false otherwise.
val fetch_and_add : int t -> int -> intfetch_and_add r n atomically increments the value of r by n, and returns the current value (before the increment).
val incr : int t -> unitincr r atomically increments the value of r by 1.
val decr : int t -> unitdecr r atomically decrements the value of r by 1.
Bigarray.Array0Zero-dimensional arrays. The Array0 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of zero-dimensional arrays that only contain a single scalar value. Statically knowing the number of dimensions of the array allows faster operations, and more precise static type-checking.
The type of zero-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
Array0.create kind layout returns a new Bigarray of zero dimension. kind and layout determine the array element kind and the array layout as described for Genarray.create.
Array0.init kind layout v behaves like Array0.create kind layout except that the element is additionally initialized to the value v.
Array0.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a. No copying of elements is involved: the new array and the original array share the same storage space.
val size_in_bytes : ('a, 'b, 'c) t -> intsize_in_bytes a is a's kind_size_in_bytes.
val get : ('a, 'b, 'c) t -> 'aArray0.get a returns the only element in a.
val set : ('a, 'b, 'c) t -> 'a -> unitArray0.set a x v stores the value v in a.
Copy the first Bigarray to the second Bigarray. See Genarray.blit for more details.
val fill : ('a, 'b, 'c) t -> 'a -> unitFill the given Bigarray with the given value. See Genarray.fill for more details.
Bigarray.Array1One-dimensional arrays. The Array1 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of one-dimensional arrays. (The Array2 and Array3 structures below provide operations specialized for two- and three-dimensional arrays.) Statically knowing the number of dimensions of the array allows faster operations, and more precise static type-checking.
The type of one-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
Array1.create kind layout dim returns a new Bigarray of one dimension, whose size is dim. kind and layout determine the array element kind and the array layout as described for Genarray.create.
Array1.init kind layout dim f returns a new Bigarray b of one dimension, whose size is dim. kind and layout determine the array element kind and the array layout as described for Genarray.create.
Each element Array1.get b i of the array is initialized to the result of f i.
In other words, Array1.init kind layout dimensions f tabulates the results of f applied to the indices of a new Bigarray whose layout is described by kind, layout and dim.
val dim : ('a, 'b, 'c) t -> intReturn the size (dimension) of the given one-dimensional Bigarray.
Array1.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimension as a). No copying of elements is involved: the new array and the original array share the same storage space.
val size_in_bytes : ('a, 'b, 'c) t -> intsize_in_bytes a is the number of elements in a multiplied by a's kind_size_in_bytes.
val get : ('a, 'b, 'c) t -> int -> 'aArray1.get a x, or alternatively a.{x}, returns the element of a at index x. x must be greater or equal than 0 and strictly less than Array1.dim a if a has C layout. If a has Fortran layout, x must be greater or equal than 1 and less or equal than Array1.dim a. Otherwise, Invalid_argument is raised.
val set : ('a, 'b, 'c) t -> int -> 'a -> unitArray1.set a x v, also written a.{x} <- v, stores the value v at index x in a. x must be inside the bounds of a as described in Bigarray.Array1.get; otherwise, Invalid_argument is raised.
Extract a sub-array of the given one-dimensional Bigarray. See Genarray.sub_left for more details.
Extract a scalar (zero-dimensional slice) of the given one-dimensional Bigarray. The integer parameter is the index of the scalar to extract. See Bigarray.Genarray.slice_left and Bigarray.Genarray.slice_right for more details.
Copy the first Bigarray to the second Bigarray. See Genarray.blit for more details.
val fill : ('a, 'b, 'c) t -> 'a -> unitFill the given Bigarray with the given value. See Genarray.fill for more details.
Build a one-dimensional Bigarray initialized from the given array.
val unsafe_get : ('a, 'b, 'c) t -> int -> 'aLike Bigarray.Array1.get, but bounds checking is not always performed. Use with caution and only when the program logic guarantees that the access is within bounds.
val unsafe_set : ('a, 'b, 'c) t -> int -> 'a -> unitLike Bigarray.Array1.set, but bounds checking is not always performed. Use with caution and only when the program logic guarantees that the access is within bounds.
Bigarray.Array2Two-dimensional arrays. The Array2 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of two-dimensional arrays.
The type of two-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
Array2.create kind layout dim1 dim2 returns a new Bigarray of two dimensions, whose size is dim1 in the first dimension and dim2 in the second dimension. kind and layout determine the array element kind and the array layout as described for Bigarray.Genarray.create.
val init :
+ ('a, 'b) kind ->
+ 'c layout ->
+ int ->
+ int ->
+ (int -> int -> 'a) ->
+ ('a, 'b, 'c) tArray2.init kind layout dim1 dim2 f returns a new Bigarray b of two dimensions, whose size is dim2 in the first dimension and dim2 in the second dimension. kind and layout determine the array element kind and the array layout as described for Bigarray.Genarray.create.
Each element Array2.get b i j of the array is initialized to the result of f i j.
In other words, Array2.init kind layout dim1 dim2 f tabulates the results of f applied to the indices of a new Bigarray whose layout is described by kind, layout, dim1 and dim2.
val dim1 : ('a, 'b, 'c) t -> intReturn the first dimension of the given two-dimensional Bigarray.
val dim2 : ('a, 'b, 'c) t -> intReturn the second dimension of the given two-dimensional Bigarray.
Array2.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a). No copying of elements is involved: the new array and the original array share the same storage space. The dimensions are reversed, such that get v [| a; b |] in C layout becomes get v [| b+1; a+1 |] in Fortran layout.
val size_in_bytes : ('a, 'b, 'c) t -> intsize_in_bytes a is the number of elements in a multiplied by a's kind_size_in_bytes.
val get : ('a, 'b, 'c) t -> int -> int -> 'aArray2.get a x y, also written a.{x,y}, returns the element of a at coordinates (x, y). x and y must be within the bounds of a, as described for Bigarray.Genarray.get; otherwise, Invalid_argument is raised.
val set : ('a, 'b, 'c) t -> int -> int -> 'a -> unitArray2.set a x y v, or alternatively a.{x,y} <- v, stores the value v at coordinates (x, y) in a. x and y must be within the bounds of a, as described for Bigarray.Genarray.set; otherwise, Invalid_argument is raised.
Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the first dimension. See Bigarray.Genarray.sub_left for more details. Array2.sub_left applies only to arrays with C layout.
val sub_right :
+ ('a, 'b, fortran_layout) t ->
+ int ->
+ int ->
+ ('a, 'b, fortran_layout) tExtract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the second dimension. See Bigarray.Genarray.sub_right for more details. Array2.sub_right applies only to arrays with Fortran layout.
Extract a row (one-dimensional slice) of the given two-dimensional Bigarray. The integer parameter is the index of the row to extract. See Bigarray.Genarray.slice_left for more details. Array2.slice_left applies only to arrays with C layout.
val slice_right :
+ ('a, 'b, fortran_layout) t ->
+ int ->
+ ('a, 'b, fortran_layout) Array1.tExtract a column (one-dimensional slice) of the given two-dimensional Bigarray. The integer parameter is the index of the column to extract. See Bigarray.Genarray.slice_right for more details. Array2.slice_right applies only to arrays with Fortran layout.
Copy the first Bigarray to the second Bigarray. See Bigarray.Genarray.blit for more details.
val fill : ('a, 'b, 'c) t -> 'a -> unitFill the given Bigarray with the given value. See Bigarray.Genarray.fill for more details.
Build a two-dimensional Bigarray initialized from the given array of arrays.
val unsafe_get : ('a, 'b, 'c) t -> int -> int -> 'aLike Bigarray.Array2.get, but bounds checking is not always performed.
val unsafe_set : ('a, 'b, 'c) t -> int -> int -> 'a -> unitLike Bigarray.Array2.set, but bounds checking is not always performed.
Bigarray.Array3Three-dimensional arrays. The Array3 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of three-dimensional arrays.
The type of three-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
Array3.create kind layout dim1 dim2 dim3 returns a new Bigarray of three dimensions, whose size is dim1 in the first dimension, dim2 in the second dimension, and dim3 in the third. kind and layout determine the array element kind and the array layout as described for Bigarray.Genarray.create.
val init :
+ ('a, 'b) kind ->
+ 'c layout ->
+ int ->
+ int ->
+ int ->
+ (int -> int -> int -> 'a) ->
+ ('a, 'b, 'c) tArray3.init kind layout dim1 dim2 dim3 f returns a new Bigarray b of three dimensions, whose size is dim1 in the first dimension, dim2 in the second dimension, and dim3 in the third. kind and layout determine the array element kind and the array layout as described for Bigarray.Genarray.create.
Each element Array3.get b i j k of the array is initialized to the result of f i j k.
In other words, Array3.init kind layout dim1 dim2 dim3 f tabulates the results of f applied to the indices of a new Bigarray whose layout is described by kind, layout, dim1, dim2 and dim3.
val dim1 : ('a, 'b, 'c) t -> intReturn the first dimension of the given three-dimensional Bigarray.
val dim2 : ('a, 'b, 'c) t -> intReturn the second dimension of the given three-dimensional Bigarray.
val dim3 : ('a, 'b, 'c) t -> intReturn the third dimension of the given three-dimensional Bigarray.
Array3.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a). No copying of elements is involved: the new array and the original array share the same storage space. The dimensions are reversed, such that get v [| a; b; c |] in C layout becomes get v [| c+1; b+1; a+1 |] in Fortran layout.
val size_in_bytes : ('a, 'b, 'c) t -> intsize_in_bytes a is the number of elements in a multiplied by a's kind_size_in_bytes.
val get : ('a, 'b, 'c) t -> int -> int -> int -> 'aArray3.get a x y z, also written a.{x,y,z}, returns the element of a at coordinates (x, y, z). x, y and z must be within the bounds of a, as described for Bigarray.Genarray.get; otherwise, Invalid_argument is raised.
val set : ('a, 'b, 'c) t -> int -> int -> int -> 'a -> unitArray3.set a x y v, or alternatively a.{x,y,z} <- v, stores the value v at coordinates (x, y, z) in a. x, y and z must be within the bounds of a, as described for Bigarray.Genarray.set; otherwise, Invalid_argument is raised.
Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the first dimension. See Bigarray.Genarray.sub_left for more details. Array3.sub_left applies only to arrays with C layout.
val sub_right :
+ ('a, 'b, fortran_layout) t ->
+ int ->
+ int ->
+ ('a, 'b, fortran_layout) tExtract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the second dimension. See Bigarray.Genarray.sub_right for more details. Array3.sub_right applies only to arrays with Fortran layout.
Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the first two coordinates. The integer parameters are the coordinates of the slice to extract. See Bigarray.Genarray.slice_left for more details. Array3.slice_left_1 applies only to arrays with C layout.
val slice_right_1 :
+ ('a, 'b, fortran_layout) t ->
+ int ->
+ int ->
+ ('a, 'b, fortran_layout) Array1.tExtract a one-dimensional slice of the given three-dimensional Bigarray by fixing the last two coordinates. The integer parameters are the coordinates of the slice to extract. See Bigarray.Genarray.slice_right for more details. Array3.slice_right_1 applies only to arrays with Fortran layout.
Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the first coordinate. The integer parameter is the first coordinate of the slice to extract. See Bigarray.Genarray.slice_left for more details. Array3.slice_left_2 applies only to arrays with C layout.
val slice_right_2 :
+ ('a, 'b, fortran_layout) t ->
+ int ->
+ ('a, 'b, fortran_layout) Array2.tExtract a two-dimensional slice of the given three-dimensional Bigarray by fixing the last coordinate. The integer parameter is the coordinate of the slice to extract. See Bigarray.Genarray.slice_right for more details. Array3.slice_right_2 applies only to arrays with Fortran layout.
Copy the first Bigarray to the second Bigarray. See Bigarray.Genarray.blit for more details.
val fill : ('a, 'b, 'c) t -> 'a -> unitFill the given Bigarray with the given value. See Bigarray.Genarray.fill for more details.
Build a three-dimensional Bigarray initialized from the given array of arrays of arrays.
val unsafe_get : ('a, 'b, 'c) t -> int -> int -> int -> 'aLike Bigarray.Array3.get, but bounds checking is not always performed.
val unsafe_set : ('a, 'b, 'c) t -> int -> int -> int -> 'a -> unitLike Bigarray.Array3.set, but bounds checking is not always performed.
Bigarray.GenarrayThe type Genarray.t is the type of Bigarrays with variable numbers of dimensions. Any number of dimensions between 0 and 16 is supported.
The three type parameters to Genarray.t identify the array element kind and layout, as follows:
'a, is the OCaml type for accessing array elements (float, int, int32, int64, nativeint);'b, is the actual kind of array elements (float32_elt, float64_elt, int8_signed_elt, int8_unsigned_elt, etc);'c, identifies the array layout (c_layout or fortran_layout).For instance, (float, float32_elt, fortran_layout) Genarray.t is the type of generic Bigarrays containing 32-bit floats in Fortran layout; reads and writes in this array use the OCaml type float.
Genarray.create kind layout dimensions returns a new Bigarray whose element kind is determined by the parameter kind (one of float32, float64, int8_signed, etc) and whose layout is determined by the parameter layout (one of c_layout or fortran_layout). The dimensions parameter is an array of integers that indicate the size of the Bigarray in each dimension. The length of dimensions determines the number of dimensions of the Bigarray.
For instance, Genarray.create int32 c_layout [|4;6;8|] returns a fresh Bigarray of 32-bit integers, in C layout, having three dimensions, the three dimensions being 4, 6 and 8 respectively.
Bigarrays returned by Genarray.create are not initialized: the initial values of array elements is unspecified.
Genarray.create raises Invalid_argument if the number of dimensions is not in the range 0 to 16 inclusive, or if one of the dimensions is negative.
Genarray.init kind layout dimensions f returns a new Bigarray b whose element kind is determined by the parameter kind (one of float32, float64, int8_signed, etc) and whose layout is determined by the parameter layout (one of c_layout or fortran_layout). The dimensions parameter is an array of integers that indicate the size of the Bigarray in each dimension. The length of dimensions determines the number of dimensions of the Bigarray.
Each element Genarray.get b i is initialized to the result of f i. In other words, Genarray.init kind layout dimensions f tabulates the results of f applied to the indices of a new Bigarray whose layout is described by kind, layout and dimensions. The index array i may be shared and mutated between calls to f.
For instance, Genarray.init int c_layout [|2; 1; 3|]
+ (Array.fold_left (+) 0) returns a fresh Bigarray of integers, in C layout, having three dimensions (2, 1, 3, respectively), with the element values 0, 1, 2, 1, 2, 3.
Genarray.init raises Invalid_argument if the number of dimensions is not in the range 0 to 16 inclusive, or if one of the dimensions is negative.
val num_dims : ('a, 'b, 'c) t -> intReturn the number of dimensions of the given Bigarray.
val dims : ('a, 'b, 'c) t -> int arrayGenarray.dims a returns all dimensions of the Bigarray a, as an array of integers of length Genarray.num_dims a.
val nth_dim : ('a, 'b, 'c) t -> int -> intGenarray.nth_dim a n returns the n-th dimension of the Bigarray a. The first dimension corresponds to n = 0; the second dimension corresponds to n = 1; the last dimension, to n = Genarray.num_dims a - 1.
Genarray.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a). No copying of elements is involved: the new array and the original array share the same storage space. The dimensions are reversed, such that get v [| a; b |] in C layout becomes get v [| b+1; a+1 |] in Fortran layout.
val size_in_bytes : ('a, 'b, 'c) t -> intsize_in_bytes a is the number of elements in a multiplied by a's kind_size_in_bytes.
val get : ('a, 'b, 'c) t -> int array -> 'aRead an element of a generic Bigarray. Genarray.get a [|i1; ...; iN|] returns the element of a whose coordinates are i1 in the first dimension, i2 in the second dimension, ..., iN in the N-th dimension.
If a has C layout, the coordinates must be greater or equal than 0 and strictly less than the corresponding dimensions of a. If a has Fortran layout, the coordinates must be greater or equal than 1 and less or equal than the corresponding dimensions of a.
If N > 3, alternate syntax is provided: you can write a.{i1, i2, ..., iN} instead of Genarray.get a [|i1; ...; iN|]. (The syntax a.{...} with one, two or three coordinates is reserved for accessing one-, two- and three-dimensional arrays as described below.)
val set : ('a, 'b, 'c) t -> int array -> 'a -> unitAssign an element of a generic Bigarray. Genarray.set a [|i1; ...; iN|] v stores the value v in the element of a whose coordinates are i1 in the first dimension, i2 in the second dimension, ..., iN in the N-th dimension.
The array a must have exactly N dimensions, and all coordinates must lie inside the array bounds, as described for Genarray.get; otherwise, Invalid_argument is raised.
If N > 3, alternate syntax is provided: you can write a.{i1, i2, ..., iN} <- v instead of Genarray.set a [|i1; ...; iN|] v. (The syntax a.{...} <- v with one, two or three coordinates is reserved for updating one-, two- and three-dimensional arrays as described below.)
Extract a sub-array of the given Bigarray by restricting the first (left-most) dimension. Genarray.sub_left a ofs len returns a Bigarray with the same number of dimensions as a, and the same dimensions as a, except the first dimension, which corresponds to the interval [ofs ... ofs + len - 1] of the first dimension of a. No copying of elements is involved: the sub-array and the original array share the same storage space. In other terms, the element at coordinates [|i1; ...; iN|] of the sub-array is identical to the element at coordinates [|i1+ofs; ...; iN|] of the original array a.
Genarray.sub_left applies only to Bigarrays in C layout.
val sub_right :
+ ('a, 'b, fortran_layout) t ->
+ int ->
+ int ->
+ ('a, 'b, fortran_layout) tExtract a sub-array of the given Bigarray by restricting the last (right-most) dimension. Genarray.sub_right a ofs len returns a Bigarray with the same number of dimensions as a, and the same dimensions as a, except the last dimension, which corresponds to the interval [ofs ... ofs + len - 1] of the last dimension of a. No copying of elements is involved: the sub-array and the original array share the same storage space. In other terms, the element at coordinates [|i1; ...; iN|] of the sub-array is identical to the element at coordinates [|i1; ...; iN+ofs|] of the original array a.
Genarray.sub_right applies only to Bigarrays in Fortran layout.
Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the first (left-most) coordinates. Genarray.slice_left a [|i1; ... ; iM|] returns the 'slice' of a obtained by setting the first M coordinates to i1, ..., iM. If a has N dimensions, the slice has dimension N - M, and the element at coordinates [|j1; ...; j(N-M)|] in the slice is identical to the element at coordinates [|i1; ...; iM; j1; ...; j(N-M)|] in the original array a. No copying of elements is involved: the slice and the original array share the same storage space.
Genarray.slice_left applies only to Bigarrays in C layout.
val slice_right :
+ ('a, 'b, fortran_layout) t ->
+ int array ->
+ ('a, 'b, fortran_layout) tExtract a sub-array of lower dimension from the given Bigarray by fixing one or several of the last (right-most) coordinates. Genarray.slice_right a [|i1; ... ; iM|] returns the 'slice' of a obtained by setting the last M coordinates to i1, ..., iM. If a has N dimensions, the slice has dimension N - M, and the element at coordinates [|j1; ...; j(N-M)|] in the slice is identical to the element at coordinates [|j1; ...; j(N-M); i1; ...; iM|] in the original array a. No copying of elements is involved: the slice and the original array share the same storage space.
Genarray.slice_right applies only to Bigarrays in Fortran layout.
Copy all elements of a Bigarray in another Bigarray. Genarray.blit src dst copies all elements of src into dst. Both arrays src and dst must have the same number of dimensions and equal dimensions. Copying a sub-array of src to a sub-array of dst can be achieved by applying Genarray.blit to sub-array or slices of src and dst.
val fill : ('a, 'b, 'c) t -> 'a -> unitSet all elements of a Bigarray to a given value. Genarray.fill a v stores the value v in all elements of the Bigarray a. Setting only some elements of a to v can be achieved by applying Genarray.fill to a sub-array or a slice of a.
Stdlib.BigarrayLarge, multi-dimensional, numerical arrays.
This module implements multi-dimensional arrays of integers and floating-point numbers, thereafter referred to as 'Bigarrays', to distinguish them from the standard OCaml arrays described in Array.
The implementation allows efficient sharing of large numerical arrays between OCaml code and C or Fortran numerical libraries.
The main differences between 'Bigarrays' and standard OCaml arrays are as follows:
Users of this module are encouraged to do open Bigarray in their source, then refer to array types and operations via short dot notation, e.g. Array1.t or Array2.sub.
Bigarrays support all the OCaml ad-hoc polymorphic operations:
=, <>, <=, etc, as well as Stdlib.compare);Hash);Marshal module, as well as Stdlib.output_value and Stdlib.input_value).Bigarrays can contain elements of the following kinds:
Bigarray.float32_elt),Bigarray.float64_elt),Bigarray.complex32_elt),Bigarray.complex64_elt),Bigarray.int8_signed_elt or Bigarray.int8_unsigned_elt),Bigarray.int16_signed_elt or Bigarray.int16_unsigned_elt),Bigarray.int_elt),Bigarray.int32_elt),Bigarray.int64_elt),Bigarray.nativeint_elt).Each element kind is represented at the type level by one of the *_elt types defined below (defined with a single constructor instead of abstract types for technical injectivity reasons).
type ('a, 'b) kind = | Float32 : (float, float32_elt) kind| Float64 : (float, float64_elt) kind| Int8_signed : (int, int8_signed_elt) kind| Int8_unsigned : (int, int8_unsigned_elt) kind| Int16_signed : (int, int16_signed_elt) kind| Int16_unsigned : (int, int16_unsigned_elt) kind| Int32 : (int32, int32_elt) kind| Int64 : (int64, int64_elt) kind| Int : (int, int_elt) kind| Nativeint : (nativeint, nativeint_elt) kind| Complex32 : (Complex.t, complex32_elt) kind| Complex64 : (Complex.t, complex64_elt) kind| Char : (char, int8_unsigned_elt) kindTo each element kind is associated an OCaml type, which is the type of OCaml values that can be stored in the Bigarray or read back from it. This type is not necessarily the same as the type of the array elements proper: for instance, a Bigarray whose elements are of kind float32_elt contains 32-bit single precision floats, but reading or writing one of its elements from OCaml uses the OCaml type float, which is 64-bit double precision floats.
The GADT type ('a, 'b) kind captures this association of an OCaml type 'a for values read or written in the Bigarray, and of an element kind 'b which represents the actual contents of the Bigarray. Its constructors list all possible associations of OCaml types with element kinds, and are re-exported below for backward-compatibility reasons.
Using a generalized algebraic datatype (GADT) here allows writing well-typed polymorphic functions whose return type depend on the argument type, such as:
let zero : type a b. (a, b) kind -> a = function
+ | Float32 -> 0.0 | Complex32 -> Complex.zero
+ | Float64 -> 0.0 | Complex64 -> Complex.zero
+ | Int8_signed -> 0 | Int8_unsigned -> 0
+ | Int16_signed -> 0 | Int16_unsigned -> 0
+ | Int32 -> 0l | Int64 -> 0L
+ | Int -> 0 | Nativeint -> 0n
+ | Char -> '\000'val float32 : (float, float32_elt) kindSee Bigarray.char.
val float64 : (float, float64_elt) kindSee Bigarray.char.
val complex32 : (Complex.t, complex32_elt) kindSee Bigarray.char.
val complex64 : (Complex.t, complex64_elt) kindSee Bigarray.char.
val int8_signed : (int, int8_signed_elt) kindSee Bigarray.char.
val int8_unsigned : (int, int8_unsigned_elt) kindSee Bigarray.char.
val int16_signed : (int, int16_signed_elt) kindSee Bigarray.char.
val int16_unsigned : (int, int16_unsigned_elt) kindSee Bigarray.char.
See Bigarray.char.
See Bigarray.char.
See Bigarray.char.
val nativeint : (nativeint, nativeint_elt) kindSee Bigarray.char.
val char : (char, int8_unsigned_elt) kindAs shown by the types of the values above, Bigarrays of kind float32_elt and float64_elt are accessed using the OCaml type float. Bigarrays of complex kinds complex32_elt, complex64_elt are accessed with the OCaml type Complex.t. Bigarrays of integer kinds are accessed using the smallest OCaml integer type large enough to represent the array elements: int for 8- and 16-bit integer Bigarrays, as well as OCaml-integer Bigarrays; int32 for 32-bit integer Bigarrays; int64 for 64-bit integer Bigarrays; and nativeint for platform-native integer Bigarrays. Finally, Bigarrays of kind int8_unsigned_elt can also be accessed as arrays of characters instead of arrays of small integers, by using the kind value char instead of int8_unsigned.
val kind_size_in_bytes : ('a, 'b) kind -> intkind_size_in_bytes k is the number of bytes used to store an element of type k.
To facilitate interoperability with existing C and Fortran code, this library supports two different memory layouts for Bigarrays, one compatible with the C conventions, the other compatible with the Fortran conventions.
In the C-style layout, array indices start at 0, and multi-dimensional arrays are laid out in row-major format. That is, for a two-dimensional array, all elements of row 0 are contiguous in memory, followed by all elements of row 1, etc. In other terms, the array elements at (x,y) and (x, y+1) are adjacent in memory.
In the Fortran-style layout, array indices start at 1, and multi-dimensional arrays are laid out in column-major format. That is, for a two-dimensional array, all elements of column 0 are contiguous in memory, followed by all elements of column 1, etc. In other terms, the array elements at (x,y) and (x+1, y) are adjacent in memory.
Each layout style is identified at the type level by the phantom types Bigarray.c_layout and Bigarray.fortran_layout respectively.
The GADT type 'a layout represents one of the two supported memory layouts: C-style or Fortran-style. Its constructors are re-exported as values below for backward-compatibility reasons.
val fortran_layout : fortran_layout layoutmodule Genarray : sig ... endmodule Array0 : sig ... endZero-dimensional arrays. The Array0 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of zero-dimensional arrays that only contain a single scalar value. Statically knowing the number of dimensions of the array allows faster operations, and more precise static type-checking.
module Array1 : sig ... endOne-dimensional arrays. The Array1 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of one-dimensional arrays. (The Array2 and Array3 structures below provide operations specialized for two- and three-dimensional arrays.) Statically knowing the number of dimensions of the array allows faster operations, and more precise static type-checking.
module Array2 : sig ... endTwo-dimensional arrays. The Array2 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of two-dimensional arrays.
module Array3 : sig ... endThree-dimensional arrays. The Array3 structure provides operations similar to those of Bigarray.Genarray, but specialized to the case of three-dimensional arrays.
val genarray_of_array0 : ('a, 'b, 'c) Array0.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given zero-dimensional Bigarray.
val genarray_of_array1 : ('a, 'b, 'c) Array1.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given one-dimensional Bigarray.
val genarray_of_array2 : ('a, 'b, 'c) Array2.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given two-dimensional Bigarray.
val genarray_of_array3 : ('a, 'b, 'c) Array3.t -> ('a, 'b, 'c) Genarray.tReturn the generic Bigarray corresponding to the given three-dimensional Bigarray.
val array0_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.tReturn the zero-dimensional Bigarray corresponding to the given generic Bigarray.
val array1_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array1.tReturn the one-dimensional Bigarray corresponding to the given generic Bigarray.
val array2_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array2.tReturn the two-dimensional Bigarray corresponding to the given generic Bigarray.
val array3_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array3.tReturn the three-dimensional Bigarray corresponding to the given generic Bigarray.
val reshape : ('a, 'b, 'c) Genarray.t -> int array -> ('a, 'b, 'c) Genarray.treshape b [|d1;...;dN|] converts the Bigarray b to a N-dimensional array of dimensions d1...dN. The returned array and the original array b share their data and have the same layout. For instance, assuming that b is a one-dimensional array of dimension 12, reshape b [|3;4|] returns a two-dimensional array b' of dimensions 3 and 4. If b has C layout, the element (x,y) of b' corresponds to the element x * 3 + y of b. If b has Fortran layout, the element (x,y) of b' corresponds to the element x + (y - 1) * 4 of b. The returned Bigarray must have exactly the same number of elements as the original Bigarray b. That is, the product of the dimensions of b must be equal to i1 * ... * iN. Otherwise, Invalid_argument is raised.
val reshape_0 : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.tSpecialized version of Bigarray.reshape for reshaping to zero-dimensional arrays.
val reshape_1 : ('a, 'b, 'c) Genarray.t -> int -> ('a, 'b, 'c) Array1.tSpecialized version of Bigarray.reshape for reshaping to one-dimensional arrays.
val reshape_2 : ('a, 'b, 'c) Genarray.t -> int -> int -> ('a, 'b, 'c) Array2.tSpecialized version of Bigarray.reshape for reshaping to two-dimensional arrays.
val reshape_3 :
+ ('a, 'b, 'c) Genarray.t ->
+ int ->
+ int ->
+ int ->
+ ('a, 'b, 'c) Array3.tSpecialized version of Bigarray.reshape for reshaping to three-dimensional arrays.
Stdlib.BoolBoolean values.
The type of booleans (truth values).
The constructors false and true are included here so that they have paths, but they are not intended to be used in user-defined data types.
e0 && e1 is the lazy boolean conjunction of expressions e0 and e1. If e0 evaluates to false, e1 is not evaluated. Right-associative operator at precedence level 3/11.
e0 || e1 is the lazy boolean disjunction of expressions e0 and e1. If e0 evaluates to true, e1 is not evaluated. Right-associative operator at precedence level 2/11.
equal b0 b1 is true if and only if b0 and b1 are both true or both false.
compare b0 b1 is a total order on boolean values. false is smaller than true.
Stdlib.BufferExtensible buffers.
This module implements buffers that automatically expand as necessary. It provides accumulative concatenation of strings in linear time (instead of quadratic time when strings are concatenated pairwise). For example:
let concat_strings ss =
+ let b = Buffer.create 16 in
+ List.iter (Buffer.add_string b) ss;
+ Buffer.contents bval create : int -> tcreate n returns a fresh buffer, initially empty. The n parameter is the initial size of the internal byte sequence that holds the buffer contents. That byte sequence is automatically reallocated when more than n characters are stored in the buffer, but shrinks back to n characters when reset is called. For best performance, n should be of the same order of magnitude as the number of characters that are expected to be stored in the buffer (for instance, 80 for a buffer that holds one output line). Nothing bad will happen if the buffer grows beyond that limit, however. In doubt, take n = 16 for instance. If n is not between 1 and Sys.max_string_length, it will be clipped to that interval.
val contents : t -> stringReturn a copy of the current contents of the buffer. The buffer itself is unchanged.
val to_bytes : t -> bytesReturn a copy of the current contents of the buffer. The buffer itself is unchanged.
val sub : t -> int -> int -> stringBuffer.sub b off len returns a copy of len bytes from the current contents of the buffer b, starting at offset off.
val blit : t -> int -> bytes -> int -> int -> unitBuffer.blit src srcoff dst dstoff len copies len characters from the current contents of the buffer src, starting at offset srcoff to dst, starting at character dstoff.
val nth : t -> int -> charGet the n-th character of the buffer.
val length : t -> intReturn the number of characters currently contained in the buffer.
val clear : t -> unitEmpty the buffer.
val reset : t -> unitEmpty the buffer and deallocate the internal byte sequence holding the buffer contents, replacing it with the initial internal byte sequence of length n that was allocated by Buffer.create n. For long-lived buffers that may have grown a lot, reset allows faster reclamation of the space used by the buffer.
val output_buffer : out_channel -> t -> unitoutput_buffer oc b writes the current contents of buffer b on the output channel oc.
val truncate : t -> int -> unittruncate b len truncates the length of b to len Note: the internal byte sequence is not shortened.
Note: all add_* operations can raise Failure if the internal byte sequence of the buffer would need to grow beyond Sys.max_string_length.
val add_char : t -> char -> unitadd_char b c appends the character c at the end of buffer b.
add_utf_8_uchar b u appends the UTF-8 encoding of u at the end of buffer b.
add_utf_16le_uchar b u appends the UTF-16LE encoding of u at the end of buffer b.
add_utf_16be_uchar b u appends the UTF-16BE encoding of u at the end of buffer b.
val add_string : t -> string -> unitadd_string b s appends the string s at the end of buffer b.
val add_bytes : t -> bytes -> unitadd_bytes b s appends the byte sequence s at the end of buffer b.
val add_substring : t -> string -> int -> int -> unitadd_substring b s ofs len takes len characters from offset ofs in string s and appends them at the end of buffer b.
val add_subbytes : t -> bytes -> int -> int -> unitadd_subbytes b s ofs len takes len characters from offset ofs in byte sequence s and appends them at the end of buffer b.
val add_substitute : t -> (string -> string) -> string -> unitadd_substitute b f s appends the string pattern s at the end of buffer b with substitution. The substitution process looks for variables into the pattern and substitutes each variable name by its value, as obtained by applying the mapping f to the variable name. Inside the string pattern, a variable name immediately follows a non-escaped $ character and is one of the following:
_ characters,$ character is a $ that immediately follows a backslash character; it then stands for a plain $.add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1. b2 is not modified.
val add_channel : t -> in_channel -> int -> unitadd_channel b ic n reads at most n characters from the input channel ic and stores them at the end of buffer b.
Iterate on the buffer, in increasing order.
The behavior is not specified if the buffer is modified during iteration.
Iterate on the buffer, in increasing order, yielding indices along chars.
The behavior is not specified if the buffer is modified during iteration.
The functions in this section append binary encodings of integers to buffers.
Little-endian (resp. big-endian) encoding means that least (resp. most) significant bytes are stored first. Big-endian is also known as network byte order. Native-endian encoding is either little-endian or big-endian depending on Sys.big_endian.
32-bit and 64-bit integers are represented by the int32 and int64 types, which can be interpreted either as signed or unsigned numbers.
8-bit and 16-bit integers are represented by the int type, which has more bits than the binary encoding. Functions that encode these values truncate their inputs to their least significant bytes.
val add_uint8 : t -> int -> unitadd_uint8 b i appends a binary unsigned 8-bit integer i to b.
val add_int8 : t -> int -> unitadd_int8 b i appends a binary signed 8-bit integer i to b.
val add_uint16_ne : t -> int -> unitadd_uint16_ne b i appends a binary native-endian unsigned 16-bit integer i to b.
val add_uint16_be : t -> int -> unitadd_uint16_be b i appends a binary big-endian unsigned 16-bit integer i to b.
val add_uint16_le : t -> int -> unitadd_uint16_le b i appends a binary little-endian unsigned 16-bit integer i to b.
val add_int16_ne : t -> int -> unitadd_int16_ne b i appends a binary native-endian signed 16-bit integer i to b.
val add_int16_be : t -> int -> unitadd_int16_be b i appends a binary big-endian signed 16-bit integer i to b.
val add_int16_le : t -> int -> unitadd_int16_le b i appends a binary little-endian signed 16-bit integer i to b.
val add_int32_ne : t -> int32 -> unitadd_int32_ne b i appends a binary native-endian 32-bit integer i to b.
val add_int32_be : t -> int32 -> unitadd_int32_be b i appends a binary big-endian 32-bit integer i to b.
val add_int32_le : t -> int32 -> unitadd_int32_le b i appends a binary little-endian 32-bit integer i to b.
val add_int64_ne : t -> int64 -> unitadd_int64_ne b i appends a binary native-endian 64-bit integer i to b.
val add_int64_be : t -> int64 -> unitadd_int64_be b i appends a binary big-endian 64-bit integer i to b.
val add_int64_le : t -> int64 -> unitadd_int64_ne b i appends a binary little-endian 64-bit integer i to b.
Stdlib.BytesByte sequence operations.
A byte sequence is a mutable data structure that contains a fixed-length sequence of bytes. Each byte can be indexed in constant time for reading or writing.
Given a byte sequence s of length l, we can access each of the l bytes of s via its index in the sequence. Indexes start at 0, and we will call an index valid in s if it falls within the range [0...l-1] (inclusive). A position is the point between two bytes or at the beginning or end of the sequence. We call a position valid in s if it falls within the range [0...l] (inclusive). Note that the byte at index n is between positions n and n+1.
Two parameters start and len are said to designate a valid range of s if len >= 0 and start and start+len are valid positions in s.
Byte sequences can be modified in place, for instance via the set and blit functions described below. See also strings (module String), which are almost the same data structure, but cannot be modified in place.
Bytes are represented by the OCaml type char.
The labeled version of this module can be used as described in the StdLabels module.
set s n c modifies s in place, replacing the byte at index n with c.
create n returns a new byte sequence of length n. The sequence is uninitialized and contains arbitrary bytes.
make n c returns a new byte sequence of length n, filled with the byte c.
init n f returns a fresh byte sequence of length n, with character i initialized to the result of f i (in increasing index order).
Return a new byte sequence that contains the same bytes as the given string.
Return a new string that contains the same bytes as the given byte sequence.
sub s pos len returns a new byte sequence of length len, containing the subsequence of s that starts at position pos and has length len.
Same as sub but return a string instead of a byte sequence.
extend s left right returns a new byte sequence that contains the bytes of s, with left uninitialized bytes prepended and right uninitialized bytes appended to it. If left or right is negative, then bytes are removed (instead of appended) from the corresponding side of s.
fill s pos len c modifies s in place, replacing len characters with c, starting at pos.
blit src src_pos dst dst_pos len copies len bytes from sequence src, starting at index src_pos, to sequence dst, starting at index dst_pos. It works correctly even if src and dst are the same byte sequence, and the source and destination intervals overlap.
blit src src_pos dst dst_pos len copies len bytes from string src, starting at index src_pos, to byte sequence dst, starting at index dst_pos.
concat sep sl concatenates the list of byte sequences sl, inserting the separator byte sequence sep between each, and returns the result as a new byte sequence.
cat s1 s2 concatenates s1 and s2 and returns the result as a new byte sequence.
iter f s applies function f in turn to all the bytes of s. It is equivalent to f (get s 0); f (get s 1); ...; f (get s
+ (length s - 1)); ().
Same as iter, but the function is applied to the index of the byte as first argument and the byte itself as second argument.
map f s applies function f in turn to all the bytes of s (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
mapi f s calls f with each character of s and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
fold_left f x s computes f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1)), where n is the length of s.
fold_right f s x computes f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...)), where n is the length of s.
for_all p s checks if all characters in s satisfy the predicate p.
exists p s checks if at least one character of s satisfies the predicate p.
Return a copy of the argument, without leading and trailing whitespace. The bytes regarded as whitespace are the ASCII characters ' ', '\012', '\n', '\r', and '\t'.
Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. All characters outside the ASCII printable range (32..126) are escaped, as well as backslash and double-quote.
index_opt s c returns the index of the first occurrence of byte c in s or None if c does not occur in s.
rindex s c returns the index of the last occurrence of byte c in s.
rindex_opt s c returns the index of the last occurrence of byte c in s or None if c does not occur in s.
index_from s i c returns the index of the first occurrence of byte c in s after position i. index s c is equivalent to index_from s 0 c.
index_from_opt s i c returns the index of the first occurrence of byte c in s after position i or None if c does not occur in s after position i. index_opt s c is equivalent to index_from_opt s 0 c.
rindex_from s i c returns the index of the last occurrence of byte c in s before position i+1. rindex s c is equivalent to rindex_from s (length s - 1) c.
rindex_from_opt s i c returns the index of the last occurrence of byte c in s before position i+1 or None if c does not occur in s before position i+1. rindex_opt s c is equivalent to rindex_from s (length s - 1) c.
contains_from s start c tests if byte c appears in s after position start. contains s c is equivalent to contains_from
+ s 0 c.
rcontains_from s stop c tests if byte c appears in s before position stop+1.
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.
Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.
Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.
The comparison function for byte sequences, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Bytes to be passed as argument to the functors Set.Make and Map.Make.
starts_with ~prefix s is true if and only if s starts with prefix.
ends_with suffix s is true if and only if s ends with suffix.
This section describes unsafe, low-level conversion functions between bytes and string. They do not copy the internal data; used improperly, they can break the immutability invariant on strings provided by the -safe-string option. They are available for expert library authors, but for most purposes you should use the always-correct to_string and of_string instead.
Unsafely convert a byte sequence into a string.
To reason about the use of unsafe_to_string, it is convenient to consider an "ownership" discipline. A piece of code that manipulates some data "owns" it; there are several disjoint ownership modes, including:
Unique ownership is linear: passing the data to another piece of code means giving up ownership (we cannot write the data again). A unique owner may decide to make the data shared (giving up mutation rights on it), but shared data may not become uniquely-owned again.
unsafe_to_string s can only be used when the caller owns the byte sequence s -- either uniquely or as shared immutable data. The caller gives up ownership of s, and gains ownership of the returned string.
There are two valid use-cases that respect this ownership discipline:
1. Creating a string by initializing and mutating a byte sequence that is never changed after initialization is performed.
let string_init len f : string =
+ let s = Bytes.create len in
+ for i = 0 to len - 1 do Bytes.set s i (f i) done;
+ Bytes.unsafe_to_string sThis function is safe because the byte sequence s will never be accessed or mutated after unsafe_to_string is called. The string_init code gives up ownership of s, and returns the ownership of the resulting string to its caller.
Note that it would be unsafe if s was passed as an additional parameter to the function f as it could escape this way and be mutated in the future -- string_init would give up ownership of s to pass it to f, and could not call unsafe_to_string safely.
We have provided the String.init, String.map and String.mapi functions to cover most cases of building new strings. You should prefer those over to_string or unsafe_to_string whenever applicable.
2. Temporarily giving ownership of a byte sequence to a function that expects a uniquely owned string and returns ownership back, so that we can mutate the sequence again after the call ended.
let bytes_length (s : bytes) =
+ String.length (Bytes.unsafe_to_string s)In this use-case, we do not promise that s will never be mutated after the call to bytes_length s. The String.length function temporarily borrows unique ownership of the byte sequence (and sees it as a string), but returns this ownership back to the caller, which may assume that s is still a valid byte sequence after the call. Note that this is only correct because we know that String.length does not capture its argument -- it could escape by a side-channel such as a memoization combinator.
The caller may not mutate s while the string is borrowed (it has temporarily given up ownership). This affects concurrent programs, but also higher-order functions: if String.length returned a closure to be called later, s should not be mutated until this closure is fully applied and returns ownership.
Unsafely convert a shared string to a byte sequence that should not be mutated.
The same ownership discipline that makes unsafe_to_string correct applies to unsafe_of_string: you may use it if you were the owner of the string value, and you will own the return bytes in the same mode.
In practice, unique ownership of string values is extremely difficult to reason about correctly. You should always assume strings are shared, never uniquely owned.
For example, string literals are implicitly shared by the compiler, so you never uniquely own them.
let incorrect = Bytes.unsafe_of_string "hello"
+let s = Bytes.of_string "hello"The first declaration is incorrect, because the string literal "hello" could be shared by the compiler with other parts of the program, and mutating incorrect is a bug. You must always use the second version, which performs a copy and is thus correct.
Assuming unique ownership of strings that are not string literals, but are (partly) built from string literals, is also incorrect. For example, mutating unsafe_of_string ("foo" ^ s) could mutate the shared string "foo" -- assuming a rope-like representation of strings. More generally, functions operating on strings will assume shared ownership, they do not preserve unique ownership. It is thus incorrect to assume unique ownership of the result of unsafe_of_string.
The only case we have reasonable confidence is safe is if the produced bytes is shared -- used as an immutable byte sequence. This is possibly useful for incremental migration of low-level programs that manipulate immutable sequences of bytes (for example Marshal.from_bytes) and previously used the string type for this purpose.
split_on_char sep s returns the list of all (possibly empty) subsequences of s that are delimited by the sep character.
The function's output is specified by the following invariants:
sep as a separator returns a byte sequence equal to the input (Bytes.concat (Bytes.make 1 sep)
+ (Bytes.split_on_char sep s) = s).sep character.Iterate on the string, in increasing index order. Modifications of the string during iteration will be reflected in the sequence.
Iterate on the string, in increasing order, yielding indices along chars
val get_utf_8_uchar : t -> int -> Uchar.utf_decodeget_utf_8_uchar b i decodes an UTF-8 character at index i in b.
set_utf_8_uchar b i u UTF-8 encodes u at index i in b and returns the number of bytes n that were written starting at i. If n is 0 there was not enough space to encode u at i and b was left untouched. Otherwise a new character can be encoded at i + n.
val is_valid_utf_8 : t -> boolis_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
val get_utf_16be_uchar : t -> int -> Uchar.utf_decodeget_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
set_utf_16be_uchar b i u UTF-16BE encodes u at index i in b and returns the number of bytes n that were written starting at i. If n is 0 there was not enough space to encode u at i and b was left untouched. Otherwise a new character can be encoded at i + n.
val is_valid_utf_16be : t -> boolis_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
val get_utf_16le_uchar : t -> int -> Uchar.utf_decodeget_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
set_utf_16le_uchar b i u UTF-16LE encodes u at index i in b and returns the number of bytes n that were written starting at i. If n is 0 there was not enough space to encode u at i and b was left untouched. Otherwise a new character can be encoded at i + n.
val is_valid_utf_16le : t -> boolis_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
The functions in this section binary encode and decode integers to and from byte sequences.
All following functions raise Invalid_argument if the space needed at index i to decode or encode the integer is not available.
Little-endian (resp. big-endian) encoding means that least (resp. most) significant bytes are stored first. Big-endian is also known as network byte order. Native-endian encoding is either little-endian or big-endian depending on Sys.big_endian.
32-bit and 64-bit integers are represented by the int32 and int64 types, which can be interpreted either as signed or unsigned numbers.
8-bit and 16-bit integers are represented by the int type, which has more bits than the binary encoding. These extra bits are handled as follows:
int values sign-extend (resp. zero-extend) their result.int values truncate their input to their least significant bytes.get_uint8 b i is b's unsigned 8-bit integer starting at byte index i.
get_int8 b i is b's signed 8-bit integer starting at byte index i.
get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at byte index i.
get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at byte index i.
get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at byte index i.
get_int16_ne b i is b's native-endian signed 16-bit integer starting at byte index i.
get_int16_be b i is b's big-endian signed 16-bit integer starting at byte index i.
get_int16_le b i is b's little-endian signed 16-bit integer starting at byte index i.
get_int32_ne b i is b's native-endian 32-bit integer starting at byte index i.
get_int32_be b i is b's big-endian 32-bit integer starting at byte index i.
get_int32_le b i is b's little-endian 32-bit integer starting at byte index i.
get_int64_ne b i is b's native-endian 64-bit integer starting at byte index i.
get_int64_be b i is b's big-endian 64-bit integer starting at byte index i.
get_int64_le b i is b's little-endian 64-bit integer starting at byte index i.
set_uint8 b i v sets b's unsigned 8-bit integer starting at byte index i to v.
set_int8 b i v sets b's signed 8-bit integer starting at byte index i to v.
set_uint16_ne b i v sets b's native-endian unsigned 16-bit integer starting at byte index i to v.
set_uint16_be b i v sets b's big-endian unsigned 16-bit integer starting at byte index i to v.
set_uint16_le b i v sets b's little-endian unsigned 16-bit integer starting at byte index i to v.
set_int16_ne b i v sets b's native-endian signed 16-bit integer starting at byte index i to v.
set_int16_be b i v sets b's big-endian signed 16-bit integer starting at byte index i to v.
set_int16_le b i v sets b's little-endian signed 16-bit integer starting at byte index i to v.
set_int32_ne b i v sets b's native-endian 32-bit integer starting at byte index i to v.
set_int32_be b i v sets b's big-endian 32-bit integer starting at byte index i to v.
set_int32_le b i v sets b's little-endian 32-bit integer starting at byte index i to v.
set_int64_ne b i v sets b's native-endian 64-bit integer starting at byte index i to v.
set_int64_be b i v sets b's big-endian 64-bit integer starting at byte index i to v.
Stdlib.BytesLabelsByte sequence operations.
A byte sequence is a mutable data structure that contains a fixed-length sequence of bytes. Each byte can be indexed in constant time for reading or writing.
Given a byte sequence s of length l, we can access each of the l bytes of s via its index in the sequence. Indexes start at 0, and we will call an index valid in s if it falls within the range [0...l-1] (inclusive). A position is the point between two bytes or at the beginning or end of the sequence. We call a position valid in s if it falls within the range [0...l] (inclusive). Note that the byte at index n is between positions n and n+1.
Two parameters start and len are said to designate a valid range of s if len >= 0 and start and start+len are valid positions in s.
Byte sequences can be modified in place, for instance via the set and blit functions described below. See also strings (module String), which are almost the same data structure, but cannot be modified in place.
Bytes are represented by the OCaml type char.
The labeled version of this module can be used as described in the StdLabels module.
set s n c modifies s in place, replacing the byte at index n with c.
create n returns a new byte sequence of length n. The sequence is uninitialized and contains arbitrary bytes.
make n c returns a new byte sequence of length n, filled with the byte c.
init n f returns a fresh byte sequence of length n, with character i initialized to the result of f i (in increasing index order).
Return a new byte sequence that contains the same bytes as the given string.
Return a new string that contains the same bytes as the given byte sequence.
sub s ~pos ~len returns a new byte sequence of length len, containing the subsequence of s that starts at position pos and has length len.
Same as sub but return a string instead of a byte sequence.
extend s ~left ~right returns a new byte sequence that contains the bytes of s, with left uninitialized bytes prepended and right uninitialized bytes appended to it. If left or right is negative, then bytes are removed (instead of appended) from the corresponding side of s.
fill s ~pos ~len c modifies s in place, replacing len characters with c, starting at pos.
blit ~src ~src_pos ~dst ~dst_pos ~len copies len bytes from sequence src, starting at index src_pos, to sequence dst, starting at index dst_pos. It works correctly even if src and dst are the same byte sequence, and the source and destination intervals overlap.
val blit_string :
+ src:string ->
+ src_pos:int ->
+ dst:bytes ->
+ dst_pos:int ->
+ len:int ->
+ unitblit ~src ~src_pos ~dst ~dst_pos ~len copies len bytes from string src, starting at index src_pos, to byte sequence dst, starting at index dst_pos.
concat ~sep sl concatenates the list of byte sequences sl, inserting the separator byte sequence sep between each, and returns the result as a new byte sequence.
cat s1 s2 concatenates s1 and s2 and returns the result as a new byte sequence.
iter ~f s applies function f in turn to all the bytes of s. It is equivalent to f (get s 0); f (get s 1); ...; f (get s
+ (length s - 1)); ().
Same as iter, but the function is applied to the index of the byte as first argument and the byte itself as second argument.
map ~f s applies function f in turn to all the bytes of s (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
mapi ~f s calls f with each character of s and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
fold_left f x s computes f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1)), where n is the length of s.
fold_right f s x computes f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...)), where n is the length of s.
for_all p s checks if all characters in s satisfy the predicate p.
exists p s checks if at least one character of s satisfies the predicate p.
Return a copy of the argument, without leading and trailing whitespace. The bytes regarded as whitespace are the ASCII characters ' ', '\012', '\n', '\r', and '\t'.
Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. All characters outside the ASCII printable range (32..126) are escaped, as well as backslash and double-quote.
index_opt s c returns the index of the first occurrence of byte c in s or None if c does not occur in s.
rindex s c returns the index of the last occurrence of byte c in s.
rindex_opt s c returns the index of the last occurrence of byte c in s or None if c does not occur in s.
index_from s i c returns the index of the first occurrence of byte c in s after position i. index s c is equivalent to index_from s 0 c.
index_from_opt s i c returns the index of the first occurrence of byte c in s after position i or None if c does not occur in s after position i. index_opt s c is equivalent to index_from_opt s 0 c.
rindex_from s i c returns the index of the last occurrence of byte c in s before position i+1. rindex s c is equivalent to rindex_from s (length s - 1) c.
rindex_from_opt s i c returns the index of the last occurrence of byte c in s before position i+1 or None if c does not occur in s before position i+1. rindex_opt s c is equivalent to rindex_from s (length s - 1) c.
contains_from s start c tests if byte c appears in s after position start. contains s c is equivalent to contains_from
+ s 0 c.
rcontains_from s stop c tests if byte c appears in s before position stop+1.
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.
Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.
Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.
The comparison function for byte sequences, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Bytes to be passed as argument to the functors Set.Make and Map.Make.
starts_with ~prefix s is true if and only if s starts with prefix.
ends_with suffix s is true if and only if s ends with suffix.
This section describes unsafe, low-level conversion functions between bytes and string. They do not copy the internal data; used improperly, they can break the immutability invariant on strings provided by the -safe-string option. They are available for expert library authors, but for most purposes you should use the always-correct to_string and of_string instead.
Unsafely convert a byte sequence into a string.
To reason about the use of unsafe_to_string, it is convenient to consider an "ownership" discipline. A piece of code that manipulates some data "owns" it; there are several disjoint ownership modes, including:
Unique ownership is linear: passing the data to another piece of code means giving up ownership (we cannot write the data again). A unique owner may decide to make the data shared (giving up mutation rights on it), but shared data may not become uniquely-owned again.
unsafe_to_string s can only be used when the caller owns the byte sequence s -- either uniquely or as shared immutable data. The caller gives up ownership of s, and gains ownership of the returned string.
There are two valid use-cases that respect this ownership discipline:
1. Creating a string by initializing and mutating a byte sequence that is never changed after initialization is performed.
let string_init len f : string =
+ let s = Bytes.create len in
+ for i = 0 to len - 1 do Bytes.set s i (f i) done;
+ Bytes.unsafe_to_string sThis function is safe because the byte sequence s will never be accessed or mutated after unsafe_to_string is called. The string_init code gives up ownership of s, and returns the ownership of the resulting string to its caller.
Note that it would be unsafe if s was passed as an additional parameter to the function f as it could escape this way and be mutated in the future -- string_init would give up ownership of s to pass it to f, and could not call unsafe_to_string safely.
We have provided the String.init, String.map and String.mapi functions to cover most cases of building new strings. You should prefer those over to_string or unsafe_to_string whenever applicable.
2. Temporarily giving ownership of a byte sequence to a function that expects a uniquely owned string and returns ownership back, so that we can mutate the sequence again after the call ended.
let bytes_length (s : bytes) =
+ String.length (Bytes.unsafe_to_string s)In this use-case, we do not promise that s will never be mutated after the call to bytes_length s. The String.length function temporarily borrows unique ownership of the byte sequence (and sees it as a string), but returns this ownership back to the caller, which may assume that s is still a valid byte sequence after the call. Note that this is only correct because we know that String.length does not capture its argument -- it could escape by a side-channel such as a memoization combinator.
The caller may not mutate s while the string is borrowed (it has temporarily given up ownership). This affects concurrent programs, but also higher-order functions: if String.length returned a closure to be called later, s should not be mutated until this closure is fully applied and returns ownership.
Unsafely convert a shared string to a byte sequence that should not be mutated.
The same ownership discipline that makes unsafe_to_string correct applies to unsafe_of_string: you may use it if you were the owner of the string value, and you will own the return bytes in the same mode.
In practice, unique ownership of string values is extremely difficult to reason about correctly. You should always assume strings are shared, never uniquely owned.
For example, string literals are implicitly shared by the compiler, so you never uniquely own them.
let incorrect = Bytes.unsafe_of_string "hello"
+let s = Bytes.of_string "hello"The first declaration is incorrect, because the string literal "hello" could be shared by the compiler with other parts of the program, and mutating incorrect is a bug. You must always use the second version, which performs a copy and is thus correct.
Assuming unique ownership of strings that are not string literals, but are (partly) built from string literals, is also incorrect. For example, mutating unsafe_of_string ("foo" ^ s) could mutate the shared string "foo" -- assuming a rope-like representation of strings. More generally, functions operating on strings will assume shared ownership, they do not preserve unique ownership. It is thus incorrect to assume unique ownership of the result of unsafe_of_string.
The only case we have reasonable confidence is safe is if the produced bytes is shared -- used as an immutable byte sequence. This is possibly useful for incremental migration of low-level programs that manipulate immutable sequences of bytes (for example Marshal.from_bytes) and previously used the string type for this purpose.
split_on_char sep s returns the list of all (possibly empty) subsequences of s that are delimited by the sep character.
The function's output is specified by the following invariants:
sep as a separator returns a byte sequence equal to the input (Bytes.concat (Bytes.make 1 sep)
+ (Bytes.split_on_char sep s) = s).sep character.Iterate on the string, in increasing index order. Modifications of the string during iteration will be reflected in the sequence.
Iterate on the string, in increasing order, yielding indices along chars
val get_utf_8_uchar : t -> int -> Uchar.utf_decodeget_utf_8_uchar b i decodes an UTF-8 character at index i in b.
set_utf_8_uchar b i u UTF-8 encodes u at index i in b and returns the number of bytes n that were written starting at i. If n is 0 there was not enough space to encode u at i and b was left untouched. Otherwise a new character can be encoded at i + n.
val is_valid_utf_8 : t -> boolis_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
val get_utf_16be_uchar : t -> int -> Uchar.utf_decodeget_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
set_utf_16be_uchar b i u UTF-16BE encodes u at index i in b and returns the number of bytes n that were written starting at i. If n is 0 there was not enough space to encode u at i and b was left untouched. Otherwise a new character can be encoded at i + n.
val is_valid_utf_16be : t -> boolis_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
val get_utf_16le_uchar : t -> int -> Uchar.utf_decodeget_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
set_utf_16le_uchar b i u UTF-16LE encodes u at index i in b and returns the number of bytes n that were written starting at i. If n is 0 there was not enough space to encode u at i and b was left untouched. Otherwise a new character can be encoded at i + n.
val is_valid_utf_16le : t -> boolis_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
The functions in this section binary encode and decode integers to and from byte sequences.
All following functions raise Invalid_argument if the space needed at index i to decode or encode the integer is not available.
Little-endian (resp. big-endian) encoding means that least (resp. most) significant bytes are stored first. Big-endian is also known as network byte order. Native-endian encoding is either little-endian or big-endian depending on Sys.big_endian.
32-bit and 64-bit integers are represented by the int32 and int64 types, which can be interpreted either as signed or unsigned numbers.
8-bit and 16-bit integers are represented by the int type, which has more bits than the binary encoding. These extra bits are handled as follows:
int values sign-extend (resp. zero-extend) their result.int values truncate their input to their least significant bytes.get_uint8 b i is b's unsigned 8-bit integer starting at byte index i.
get_int8 b i is b's signed 8-bit integer starting at byte index i.
get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at byte index i.
get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at byte index i.
get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at byte index i.
get_int16_ne b i is b's native-endian signed 16-bit integer starting at byte index i.
get_int16_be b i is b's big-endian signed 16-bit integer starting at byte index i.
get_int16_le b i is b's little-endian signed 16-bit integer starting at byte index i.
get_int32_ne b i is b's native-endian 32-bit integer starting at byte index i.
get_int32_be b i is b's big-endian 32-bit integer starting at byte index i.
get_int32_le b i is b's little-endian 32-bit integer starting at byte index i.
get_int64_ne b i is b's native-endian 64-bit integer starting at byte index i.
get_int64_be b i is b's big-endian 64-bit integer starting at byte index i.
get_int64_le b i is b's little-endian 64-bit integer starting at byte index i.
set_uint8 b i v sets b's unsigned 8-bit integer starting at byte index i to v.
set_int8 b i v sets b's signed 8-bit integer starting at byte index i to v.
set_uint16_ne b i v sets b's native-endian unsigned 16-bit integer starting at byte index i to v.
set_uint16_be b i v sets b's big-endian unsigned 16-bit integer starting at byte index i to v.
set_uint16_le b i v sets b's little-endian unsigned 16-bit integer starting at byte index i to v.
set_int16_ne b i v sets b's native-endian signed 16-bit integer starting at byte index i to v.
set_int16_be b i v sets b's big-endian signed 16-bit integer starting at byte index i to v.
set_int16_le b i v sets b's little-endian signed 16-bit integer starting at byte index i to v.
set_int32_ne b i v sets b's native-endian 32-bit integer starting at byte index i to v.
set_int32_be b i v sets b's big-endian 32-bit integer starting at byte index i to v.
set_int32_le b i v sets b's little-endian 32-bit integer starting at byte index i to v.
set_int64_ne b i v sets b's native-endian 64-bit integer starting at byte index i to v.
set_int64_be b i v sets b's big-endian 64-bit integer starting at byte index i to v.
Stdlib.CallbackRegistering OCaml values with the C runtime.
This module allows OCaml values to be registered with the C runtime under a symbolic name, so that C code can later call back registered OCaml functions, or raise registered OCaml exceptions.
Callback.register n v registers the value v under the name n. C code can later retrieve a handle to v by calling caml_named_value(n).
Callback.register_exception n exn registers the exception contained in the exception value exn under the name n. C code can later retrieve a handle to the exception by calling caml_named_value(n). The exception value thus obtained is suitable for passing as first argument to raise_constant or raise_with_arg.
Stdlib.CharCharacter operations.
Return a string representing the given character, with special characters escaped following the lexical conventions of OCaml. All characters outside the ASCII printable range (32..126) are escaped, as well as backslash, double-quote, and single-quote.
Convert the given character to its equivalent lowercase character, using the ISO Latin-1 (8859-1) character set.
Convert the given character to its equivalent uppercase character, using the ISO Latin-1 (8859-1) character set.
Convert the given character to its equivalent lowercase character, using the US-ASCII character set.
Convert the given character to its equivalent uppercase character, using the US-ASCII character set.
The comparison function for characters, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Char to be passed as argument to the functors Set.Make and Map.Make.
Stdlib.ComplexComplex numbers.
This module provides arithmetic operations on complex numbers. Complex numbers are represented by their real and imaginary parts (cartesian representation). Each part is represented by a double-precision floating-point number (type float).
The type of complex numbers. re is the real part and im the imaginary part.
val zero : tThe complex number 0.
val one : tThe complex number 1.
val i : tThe complex number i.
Square root. The result x + i.y is such that x > 0 or x = 0 and y >= 0. This function has a discontinuity along the negative real axis.
val norm2 : t -> floatNorm squared: given x + i.y, returns x^2 + y^2.
val norm : t -> floatNorm: given x + i.y, returns sqrt(x^2 + y^2).
val arg : t -> floatArgument. The argument of a complex number is the angle in the complex plane between the positive real axis and a line passing through zero and the number. This angle ranges from -pi to pi. This function has a discontinuity along the negative real axis.
val polar : float -> float -> tpolar norm arg returns the complex having norm norm and argument arg.
Stdlib.DigestMD5 message digest.
This module provides functions to compute 128-bit 'digests' of arbitrary-length strings or files. The algorithm used is MD5.
The MD5 hash function is not cryptographically secure. Hence, this module should not be used for security-sensitive applications. More recent, stronger cryptographic primitives should be used instead.
The comparison function for 16-character digest, with the same specification as Stdlib.compare and the implementation shared with String.compare. Along with the type t, this function compare allows the module Digest to be passed as argument to the functors Set.Make and Map.Make.
val string : string -> tReturn the digest of the given string.
val bytes : bytes -> tReturn the digest of the given byte sequence.
val substring : string -> int -> int -> tDigest.substring s ofs len returns the digest of the substring of s starting at index ofs and containing len characters.
val subbytes : bytes -> int -> int -> tDigest.subbytes s ofs len returns the digest of the subsequence of s starting at index ofs and containing len bytes.
val channel : in_channel -> int -> tIf len is nonnegative, Digest.channel ic len reads len characters from channel ic and returns their digest, or raises End_of_file if end-of-file is reached before len characters are read. If len is negative, Digest.channel ic len reads all characters from ic until end-of-file is reached and return their digest.
val file : string -> tReturn the digest of the file whose name is given.
val output : out_channel -> t -> unitWrite a digest on the given output channel.
val input : in_channel -> tRead a digest from the given input channel.
val to_hex : t -> stringReturn the printable hexadecimal representation of the given digest.
val from_hex : string -> tConvert a hexadecimal representation back into the corresponding digest.
Stdlib.EitherEither type.
Either is the simplest and most generic sum/variant type: a value of ('a, 'b) Either.t is either a Left (v : 'a) or a Right (v : 'b).
It is a natural choice in the API of generic functions where values could fall in two different cases, possibly at different types, without assigning a specific meaning to what each case should be.
For example:
List.partition_map:
+ ('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c listIf you are looking for a parametrized type where one alternative means success and the other means failure, you should use the more specific type Result.t.
A value of ('a, 'b) Either.t contains either a value of 'a or a value of 'b
val left : 'a -> ('a, 'b) tleft v is Left v.
val right : 'b -> ('a, 'b) tright v is Right v.
val is_left : ('a, 'b) t -> boolis_left (Left v) is true, is_left (Right v) is false.
val is_right : ('a, 'b) t -> boolis_right (Left v) is false, is_right (Right v) is true.
val find_left : ('a, 'b) t -> 'a optionfind_left (Left v) is Some v, find_left (Right _) is None
val find_right : ('a, 'b) t -> 'b optionfind_right (Right v) is Some v, find_right (Left _) is None
map_left f e is Left (f v) if e is Left v and e if e is Right _.
map_right f e is Right (f v) if e is Right v and e if e is Left _.
map ~left ~right (Left v) is Left (left v), map ~left ~right (Right v) is Right (right v).
val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'cfold ~left ~right (Left v) is left v, and fold ~left ~right (Right v) is right v.
val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unititer ~left ~right (Left v) is left v, and iter ~left ~right (Right v) is right v.
val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> boolfor_all ~left ~right (Left v) is left v, and for_all ~left ~right (Right v) is right v.
MakeSeeded.Hval hash : int -> t -> intsame as Hashtbl.SeededHashedType
equality predicate used to compare a key with the one in a container. Can return EDead if the keys in the container are dead
create key data creates a container from some initials keys and one data
val get_data : 'a container -> 'a optionget_data cont returns the data if it is alive
val check_key : 'a container -> boolcheck_key cont checks if all the keys contained in the data are alive
GenHashTable.MakeSeededFunctor building an implementation of an hash table that use the container for keeping the information given
module H : sig ... endtype key = H.tval create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
Ephemeron.GenHashTableHash tables on generic containers with notion of death and aliveness.
Define a hash table on generic containers which have a notion of "death" and aliveness. If a binding is dead the hash table can automatically remove it.
module MakeSeeded (H : sig ... end) : SeededS with type key = H.tFunctor building an implementation of an hash table that use the container for keeping the information given
K1.Bucketval make : unit -> ('k, 'd) tCreate a new bucket.
val add : ('k, 'd) t -> 'k -> 'd -> unitAdd an ephemeron to the bucket.
val remove : ('k, 'd) t -> 'k -> unitremove b k removes from b the most-recently added ephemeron with key k, or does nothing if there is no such ephemeron.
val find : ('k, 'd) t -> 'k -> 'd optionReturns the data of the most-recently added ephemeron with the given key, or None if there is no such ephemeron.
val length : ('k, 'd) t -> intReturns an upper bound on the length of the bucket.
val clear : ('k, 'd) t -> unitRemove all ephemerons from the bucket.
Make.Hval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).K1.MakeFunctor building an implementation of a weak hash table
Propose the same interface as usual hash table. However since the bindings are weak, even if mem h k is true, a subsequent find h k may raise Not_found because the garbage collector can run between the two.
Moreover, the table shouldn't be modified during a call to iter. Use filter_map_inplace in this case.
module H : Hashtbl.HashedTypetype key = H.tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
MakeSeeded.Hval hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
K1.MakeSeededFunctor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded.
module H : Hashtbl.SeededHashedTypetype key = H.tval create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
Ephemeron.K1Ephemerons with one key.
val create : unit -> ('k, 'd) tEphemeron.K1.create () creates an ephemeron with one key. The data and the key are empty
val get_key : ('k, 'd) t -> 'k optionEphemeron.K1.get_key eph returns None if the key of eph is empty, Some x (where x is the key) if it is full.
val get_key_copy : ('k, 'd) t -> 'k optionEphemeron.K1.get_key_copy eph returns None if the key of eph is empty, Some x (where x is a (shallow) copy of the key) if it is full. This function has the same GC friendliness as Weak.get_copy
If the element is a custom block it is not copied.
val set_key : ('k, 'd) t -> 'k -> unitEphemeron.K1.set_key eph el sets the key of eph to be a (full) key to el
val unset_key : ('k, 'd) t -> unitEphemeron.K1.unset_key eph el sets the key of eph to be an empty key. Since there is only one key, the ephemeron starts behaving like a reference on the data.
val check_key : ('k, 'd) t -> boolEphemeron.K1.check_key eph returns true if the key of the eph is full, false if it is empty. Note that even if Ephemeron.K1.check_key eph returns true, a subsequent Ephemeron.K1.get_keyeph can return None.
Ephemeron.K1.blit_key eph1 eph2 sets the key of eph2 with the key of eph1. Contrary to using Ephemeron.K1.get_key followed by Ephemeron.K1.set_key or Ephemeron.K1.unset_key this function does not prevent the incremental GC from erasing the value in its current cycle.
val get_data : ('k, 'd) t -> 'd optionEphemeron.K1.get_data eph returns None if the data of eph is empty, Some x (where x is the data) if it is full.
val get_data_copy : ('k, 'd) t -> 'd optionEphemeron.K1.get_data_copy eph returns None if the data of eph is empty, Some x (where x is a (shallow) copy of the data) if it is full. This function has the same GC friendliness as Weak.get_copy
If the element is a custom block it is not copied.
val set_data : ('k, 'd) t -> 'd -> unitEphemeron.K1.set_data eph el sets the data of eph to be a (full) data to el
val unset_data : ('k, 'd) t -> unitEphemeron.K1.unset_data eph el sets the key of eph to be an empty key. The ephemeron starts behaving like a weak pointer.
val check_data : ('k, 'd) t -> boolEphemeron.K1.check_data eph returns true if the data of the eph is full, false if it is empty. Note that even if Ephemeron.K1.check_data eph returns true, a subsequent Ephemeron.K1.get_dataeph can return None.
Ephemeron.K1.blit_data eph1 eph2 sets the data of eph2 with the data of eph1. Contrary to using Ephemeron.K1.get_data followed by Ephemeron.K1.set_data or Ephemeron.K1.unset_data this function does not prevent the incremental GC from erasing the value in its current cycle.
val make : 'k -> 'd -> ('k, 'd) tEphemeron.K1.make k d creates an ephemeron with key k and data d.
val query : ('k, 'd) t -> 'k -> 'd optionEphemeron.K1.query eph key returns Some x (where x is the ephemeron's data) if key is physically equal to eph's key, and None if eph is empty or key is not equal to eph's key.
Functor building an implementation of a weak hash table
module MakeSeeded (H : Hashtbl.SeededHashedType) : SeededS with type key = H.tFunctor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded.
module Bucket : sig ... endK2.Bucketval make : unit -> ('k1, 'k2, 'd) tCreate a new bucket.
val add : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd -> unitAdd an ephemeron to the bucket.
val remove : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> unitremove b k1 k2 removes from b the most-recently added ephemeron with keys k1 and k2, or does nothing if there is no such ephemeron.
val find : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd optionReturns the data of the most-recently added ephemeron with the given keys, or None if there is no such ephemeron.
val length : ('k1, 'k2, 'd) t -> intReturns an upper bound on the length of the bucket.
val clear : ('k1, 'k2, 'd) t -> unitRemove all ephemerons from the bucket.
Make.H1val hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Make.H2val hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).K2.MakeFunctor building an implementation of a weak hash table
Propose the same interface as usual hash table. However since the bindings are weak, even if mem h k is true, a subsequent find h k may raise Not_found because the garbage collector can run between the two.
Moreover, the table shouldn't be modified during a call to iter. Use filter_map_inplace in this case.
module H1 : Hashtbl.HashedTypemodule H2 : Hashtbl.HashedTypeval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
MakeSeeded.H1val hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
MakeSeeded.H2val hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
K2.MakeSeededFunctor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded.
module H1 : Hashtbl.SeededHashedTypemodule H2 : Hashtbl.SeededHashedTypeval create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
Ephemeron.K2Ephemerons with two keys.
val create : unit -> ('k1, 'k2, 'd) tSame as Ephemeron.K1.create
val get_key1 : ('k1, 'k2, 'd) t -> 'k1 optionSame as Ephemeron.K1.get_key
val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 optionSame as Ephemeron.K1.get_key_copy
val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unitSame as Ephemeron.K1.set_key
val unset_key1 : ('k1, 'k2, 'd) t -> unitSame as Ephemeron.K1.unset_key
val check_key1 : ('k1, 'k2, 'd) t -> boolSame as Ephemeron.K1.check_key
val get_key2 : ('k1, 'k2, 'd) t -> 'k2 optionSame as Ephemeron.K1.get_key
val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 optionSame as Ephemeron.K1.get_key_copy
val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unitSame as Ephemeron.K1.set_key
val unset_key2 : ('k1, 'k2, 'd) t -> unitSame as Ephemeron.K1.unset_key
val check_key2 : ('k1, 'k2, 'd) t -> boolSame as Ephemeron.K1.check_key
Same as Ephemeron.K1.blit_key
Same as Ephemeron.K1.blit_key
Same as Ephemeron.K1.blit_key
val get_data : ('k1, 'k2, 'd) t -> 'd optionSame as Ephemeron.K1.get_data
val get_data_copy : ('k1, 'k2, 'd) t -> 'd optionSame as Ephemeron.K1.get_data_copy
val set_data : ('k1, 'k2, 'd) t -> 'd -> unitSame as Ephemeron.K1.set_data
val unset_data : ('k1, 'k2, 'd) t -> unitSame as Ephemeron.K1.unset_data
val check_data : ('k1, 'k2, 'd) t -> boolSame as Ephemeron.K1.check_data
Same as Ephemeron.K1.blit_data
val make : 'k1 -> 'k2 -> 'd -> ('k1, 'k2, 'd) tSame as Ephemeron.K1.make
val query : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd optionSame as Ephemeron.K1.query
module Make
+ (H1 : Hashtbl.HashedType)
+ (H2 : Hashtbl.HashedType) :
+ S with type key = H1.t * H2.tFunctor building an implementation of a weak hash table
module MakeSeeded
+ (H1 : Hashtbl.SeededHashedType)
+ (H2 : Hashtbl.SeededHashedType) :
+ SeededS with type key = H1.t * H2.tFunctor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded.
module Bucket : sig ... endKn.Bucketval make : unit -> ('k, 'd) tCreate a new bucket.
val add : ('k, 'd) t -> 'k array -> 'd -> unitAdd an ephemeron to the bucket.
val remove : ('k, 'd) t -> 'k array -> unitremove b k removes from b the most-recently added ephemeron with keys k, or does nothing if there is no such ephemeron.
val find : ('k, 'd) t -> 'k array -> 'd optionReturns the data of the most-recently added ephemeron with the given keys, or None if there is no such ephemeron.
val length : ('k, 'd) t -> intReturns an upper bound on the length of the bucket.
val clear : ('k, 'd) t -> unitRemove all ephemerons from the bucket.
Make.Hval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Kn.MakeFunctor building an implementation of a weak hash table
Propose the same interface as usual hash table. However since the bindings are weak, even if mem h k is true, a subsequent find h k may raise Not_found because the garbage collector can run between the two.
Moreover, the table shouldn't be modified during a call to iter. Use filter_map_inplace in this case.
module H : Hashtbl.HashedTypetype key = H.t arrayval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
MakeSeeded.Hval hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
Kn.MakeSeededFunctor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded.
module H : Hashtbl.SeededHashedTypetype key = H.t arrayval create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
Ephemeron.KnEphemerons with arbitrary number of keys of the same type.
val create : int -> ('k, 'd) tSame as Ephemeron.K1.create
val get_key : ('k, 'd) t -> int -> 'k optionSame as Ephemeron.K1.get_key
val get_key_copy : ('k, 'd) t -> int -> 'k optionSame as Ephemeron.K1.get_key_copy
val set_key : ('k, 'd) t -> int -> 'k -> unitSame as Ephemeron.K1.set_key
val unset_key : ('k, 'd) t -> int -> unitSame as Ephemeron.K1.unset_key
val check_key : ('k, 'd) t -> int -> boolSame as Ephemeron.K1.check_key
Same as Ephemeron.K1.blit_key
val get_data : ('k, 'd) t -> 'd optionSame as Ephemeron.K1.get_data
val get_data_copy : ('k, 'd) t -> 'd optionSame as Ephemeron.K1.get_data_copy
val set_data : ('k, 'd) t -> 'd -> unitSame as Ephemeron.K1.set_data
val unset_data : ('k, 'd) t -> unitSame as Ephemeron.K1.unset_data
val check_data : ('k, 'd) t -> boolSame as Ephemeron.K1.check_data
Same as Ephemeron.K1.blit_data
val make : 'k array -> 'd -> ('k, 'd) tSame as Ephemeron.K1.make
val query : ('k, 'd) t -> 'k array -> 'd optionSame as Ephemeron.K1.query
Functor building an implementation of a weak hash table
module MakeSeeded
+ (H : Hashtbl.SeededHashedType) :
+ SeededS with type key = H.t arrayFunctor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded.
module Bucket : sig ... endStdlib.EphemeronEphemerons and weak hash tables.
Ephemerons and weak hash tables are useful when one wants to cache or memorize the computation of a function, as long as the arguments and the function are used, without creating memory leaks by continuously keeping old computation results that are not useful anymore because one argument or the function is freed. An implementation using Hashtbl.t is not suitable because all associations would keep the arguments and the result in memory.
Ephemerons can also be used for "adding" a field to an arbitrary boxed OCaml value: you can attach some information to a value created by an external library without memory leaks.
Ephemerons hold some keys and one or no data. They are all boxed OCaml values. The keys of an ephemeron have the same behavior as weak pointers according to the garbage collector. In fact OCaml weak pointers are implemented as ephemerons without data.
The keys and data of an ephemeron are said to be full if they point to a value, or empty if the value has never been set, has been unset, or was erased by the GC. In the function that accesses the keys or data these two states are represented by the option type.
The data is considered by the garbage collector alive if all the full keys are alive and if the ephemeron is alive. When one of the keys is not considered alive anymore by the GC, the data is emptied from the ephemeron. The data could be alive for another reason and in that case the GC will not free it, but the ephemeron will not hold the data anymore.
The ephemerons complicate the notion of liveness of values, because it is not anymore an equivalence with the reachability from root value by usual pointers (not weak and not ephemerons). With ephemerons the notion of liveness is constructed by the least fixpoint of: A value is alive if:
Notes:
Stdlib.output_value or the functions of the Marshal module.Ephemerons are defined in a language agnostic way in this paper: B. Hayes, Ephemerons: A New Finalization Mechanism, OOPSLA'97
module type S = sig ... endmodule type SeededS = sig ... endThe output signature of the functors K1.MakeSeeded and K2.MakeSeeded.
module K1 : sig ... endEphemerons with one key.
module K2 : sig ... endEphemerons with two keys.
module Kn : sig ... endEphemerons with arbitrary number of keys of the same type.
module GenHashTable : sig ... endHash tables on generic containers with notion of death and aliveness.
Ephemeron.SThe output signature of the functors K1.Make and K2.Make. These hash tables are weak in the keys. If all the keys of a binding are alive the binding is kept, but if one of the keys of the binding is dead then the binding is removed.
Propose the same interface as usual hash table. However since the bindings are weak, even if mem h k is true, a subsequent find h k may raise Not_found because the garbage collector can run between the two.
Moreover, the table shouldn't be modified during a call to iter. Use filter_map_inplace in this case.
val create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
Ephemeron.SeededSThe output signature of the functors K1.MakeSeeded and K2.MakeSeeded.
val create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Hashtbl.statisticsval clean : 'a t -> unitremove all dead bindings. Done automatically during automatic resizing.
val stats_alive : 'a t -> Hashtbl.statisticssame as Hashtbl.SeededS.stats but only count the alive bindings
Stdlib.FilenameOperations on file names.
The conventional name for the parent of the current directory (e.g. .. in Unix).
concat dir file returns a file name that designates file file in directory dir.
Return true if the file name is relative to the current directory, false if it is absolute (i.e. in Unix, starts with /).
Return true if the file name is relative and does not start with an explicit reference to the current directory (./ or ../ in Unix), false if it starts with an explicit reference to the root directory or the current directory.
check_suffix name suff returns true if the filename name ends with the suffix suff.
Under Windows ports (including Cygwin), comparison is case-insensitive, relying on String.lowercase_ascii. Note that this does not match exactly the interpretation of case-insensitive filename equivalence from Windows.
chop_suffix name suff removes the suffix suff from the filename name.
chop_suffix_opt ~suffix filename removes the suffix from the filename if possible, or returns None if the filename does not end with the suffix.
Under Windows ports (including Cygwin), comparison is case-insensitive, relying on String.lowercase_ascii. Note that this does not match exactly the interpretation of case-insensitive filename equivalence from Windows.
extension name is the shortest suffix ext of name0 where:
name0 is the longest suffix of name that does not contain a directory separator;ext starts with a period;ext is preceded by at least one non-period character in name0.If such a suffix does not exist, extension name is the empty string.
Return the given file name without its extension, as defined in Filename.extension. If the extension is empty, the function returns the given file name.
The following invariant holds for any file name s:
remove_extension s ^ extension s = s
Same as Filename.remove_extension, but raise Invalid_argument if the given name has an empty extension.
Split a file name into directory name / base file name. If name is a valid file name, then concat (dirname name) (basename name) returns a file name which is equivalent to name. Moreover, after setting the current directory to dirname name (with Sys.chdir), references to basename name (which is a relative file name) designate the same file as name before the call to Sys.chdir.
This function conforms to the specification of POSIX.1-2008 for the basename utility.
See Filename.basename. This function conforms to the specification of POSIX.1-2008 for the dirname utility.
null is "/dev/null" on POSIX and "NUL" on Windows. It represents a file on the OS that discards all writes and returns end of file on reads.
temp_file prefix suffix returns the name of a fresh temporary file in the temporary directory. The base name of the temporary file is formed by concatenating prefix, then a suitably chosen integer number, then suffix. The optional argument temp_dir indicates the temporary directory to use, defaulting to the current result of Filename.get_temp_dir_name. The temporary file is created empty, with permissions 0o600 (readable and writable only by the file owner). The file is guaranteed to be different from any other file that existed when temp_file was called.
val open_temp_file :
+ ?mode:open_flag list ->
+ ?perms:int ->
+ ?temp_dir:string ->
+ string ->
+ string ->
+ string * out_channelSame as Filename.temp_file, but returns both the name of a fresh temporary file, and an output channel opened (atomically) on this file. This function is more secure than temp_file: there is no risk that the temporary file will be modified (e.g. replaced by a symbolic link) before the program opens it. The optional argument mode is a list of additional flags to control the opening of the file. It can contain one or several of Open_append, Open_binary, and Open_text. The default is [Open_text] (open in text mode). The file is created with permissions perms (defaults to readable and writable only by the file owner, 0o600).
The name of the temporary directory: Under Unix, the value of the TMPDIR environment variable, or "/tmp" if the variable is not set. Under Windows, the value of the TEMP environment variable, or "." if the variable is not set. The temporary directory can be changed with Filename.set_temp_dir_name.
Change the temporary directory returned by Filename.get_temp_dir_name and used by Filename.temp_file and Filename.open_temp_file.
The name of the initial temporary directory: Under Unix, the value of the TMPDIR environment variable, or "/tmp" if the variable is not set. Under Windows, the value of the TEMP environment variable, or "." if the variable is not set.
Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters. Warning: under Windows, the output is only suitable for use with programs that follow the standard Windows quoting conventions.
val quote_command :
+ string ->
+ ?stdin:string ->
+ ?stdout:string ->
+ ?stderr:string ->
+ string list ->
+ stringquote_command cmd args returns a quoted command line, suitable for use as an argument to Sys.command, Unix.system, and the Unix.open_process functions.
The string cmd is the command to call. The list args is the list of arguments to pass to this command. It can be empty.
The optional arguments ?stdin and ?stdout and ?stderr are file names used to redirect the standard input, the standard output, or the standard error of the command. If ~stdin:f is given, a redirection < f is performed and the standard input of the command reads from file f. If ~stdout:f is given, a redirection > f is performed and the standard output of the command is written to file f. If ~stderr:f is given, a redirection 2> f is performed and the standard error of the command is written to file f. If both ~stdout:f and ~stderr:f are given, with the exact same file name f, a 2>&1 redirection is performed so that the standard output and the standard error of the command are interleaved and redirected to the same file f.
Under Unix and Cygwin, the command, the arguments, and the redirections if any are quoted using Filename.quote, then concatenated. Under Win32, additional quoting is performed as required by the cmd.exe shell that is called by Sys.command.
Float.ArrayFloat arrays with packed representation.
val length : t -> intReturn the length (number of elements) of the given floatarray.
val get : t -> int -> floatget a n returns the element number n of floatarray a.
val set : t -> int -> float -> unitset a n x modifies floatarray a in place, replacing element number n with x.
val make : int -> float -> tmake n x returns a fresh floatarray of length n, initialized with x.
val create : int -> tcreate n returns a fresh floatarray of length n, with uninitialized data.
val init : int -> (int -> float) -> tinit n f returns a fresh floatarray of length n, with element number i initialized to the result of f i. In other terms, init n f tabulates the results of f applied to the integers 0 to n-1.
append v1 v2 returns a fresh floatarray containing the concatenation of the floatarrays v1 and v2.
sub a pos len returns a fresh floatarray of length len, containing the elements number pos to pos + len - 1 of floatarray a.
copy a returns a copy of a, that is, a fresh floatarray containing the same elements as a.
val fill : t -> int -> int -> float -> unitfill a pos len x modifies the floatarray a in place, storing x in elements number pos to pos + len - 1.
blit src src_pos dst dst_pos len copies len elements from floatarray src, starting at element number src_pos, to floatarray dst, starting at element number dst_pos. It works correctly even if src and dst are the same floatarray, and the source and destination chunks overlap.
val to_list : t -> float listto_list a returns the list of all the elements of a.
val of_list : float list -> tof_list l returns a fresh floatarray containing the elements of l.
val iter : (float -> unit) -> t -> unititer f a applies function f in turn to all the elements of a. It is equivalent to f a.(0); f a.(1); ...; f a.(length a - 1); ().
val iteri : (int -> float -> unit) -> t -> unitSame as iter, but the function is applied with the index of the element as first argument, and the element itself as second argument.
map f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
Same as map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'afold_left f x init computes f (... (f (f x init.(0)) init.(1)) ...) init.(n-1), where n is the length of the floatarray init.
val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'afold_right f a init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the floatarray a.
Array.iter2 f a b applies function f to all the elements of a and b.
map2 f a b applies function f to all the elements of a and b, and builds a floatarray with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
val for_all : (float -> bool) -> t -> boolfor_all f [|a1; ...; an|] checks if all elements of the floatarray satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an).
val exists : (float -> bool) -> t -> boolexists f [|a1; ...; an|] checks if at least one element of the floatarray satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an).
val mem : float -> t -> boolmem a set is true if and only if there is an element of set that is structurally equal to a, i.e. there is an x in set such that compare a x = 0.
val mem_ieee : float -> t -> boolSame as mem, but uses IEEE equality instead of structural equality.
val sort : (float -> float -> int) -> t -> unitSort a floatarray in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see below for a complete specification). For example, Stdlib.compare is a suitable comparison function. After calling sort, the array is sorted in place in increasing order. sort is guaranteed to run in constant heap space and (at most) logarithmic stack space.
The current implementation uses Heap Sort. It runs in constant stack space.
Specification of the comparison function: Let a be the floatarray and cmp the comparison function. The following must be true for all x, y, z in a :
cmp x y > 0 if and only if cmp y x < 0cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0When sort returns, a contains the same elements as before, reordered in such a way that for all i and j valid indices of a :
cmp a.(i) a.(j) >= 0 if and only if i >= jval stable_sort : (float -> float -> int) -> t -> unitSame as sort, but the sorting algorithm is stable (i.e. elements that compare equal are kept in their original order) and not guaranteed to run in constant heap space.
The current implementation uses Merge Sort. It uses a temporary floatarray of length n/2, where n is the length of the floatarray. It is usually faster than the current implementation of sort.
val fast_sort : (float -> float -> int) -> t -> unitSame as sort or stable_sort, whichever is faster on typical input.
Iterate on the floatarray, in increasing order. Modifications of the floatarray during iteration will be reflected in the sequence.
Iterate on the floatarray, in increasing order, yielding indices along elements. Modifications of the floatarray during iteration will be reflected in the sequence.
val map_to_array : (float -> 'a) -> t -> 'a arraymap_to_array f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].
val map_from_array : ('a -> float) -> 'a array -> tmap_from_array f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
Float.ArrayLabelsFloat arrays with packed representation (labeled functions).
val length : t -> intReturn the length (number of elements) of the given floatarray.
val get : t -> int -> floatget a n returns the element number n of floatarray a.
val set : t -> int -> float -> unitset a n x modifies floatarray a in place, replacing element number n with x.
val make : int -> float -> tmake n x returns a fresh floatarray of length n, initialized with x.
val create : int -> tcreate n returns a fresh floatarray of length n, with uninitialized data.
val init : int -> f:(int -> float) -> tinit n ~f returns a fresh floatarray of length n, with element number i initialized to the result of f i. In other terms, init n ~f tabulates the results of f applied to the integers 0 to n-1.
append v1 v2 returns a fresh floatarray containing the concatenation of the floatarrays v1 and v2.
sub a ~pos ~len returns a fresh floatarray of length len, containing the elements number pos to pos + len - 1 of floatarray a.
copy a returns a copy of a, that is, a fresh floatarray containing the same elements as a.
val fill : t -> pos:int -> len:int -> float -> unitfill a ~pos ~len x modifies the floatarray a in place, storing x in elements number pos to pos + len - 1.
blit ~src ~src_pos ~dst ~dst_pos ~len copies len elements from floatarray src, starting at element number src_pos, to floatarray dst, starting at element number dst_pos. It works correctly even if src and dst are the same floatarray, and the source and destination chunks overlap.
val to_list : t -> float listto_list a returns the list of all the elements of a.
val of_list : float list -> tof_list l returns a fresh floatarray containing the elements of l.
val iter : f:(float -> unit) -> t -> unititer ~f a applies function f in turn to all the elements of a. It is equivalent to f a.(0); f a.(1); ...; f a.(length a - 1); ().
val iteri : f:(int -> float -> unit) -> t -> unitSame as iter, but the function is applied with the index of the element as first argument, and the element itself as second argument.
map ~f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
Same as map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'afold_left ~f x ~init computes f (... (f (f x init.(0)) init.(1)) ...) init.(n-1), where n is the length of the floatarray init.
val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'afold_right f a init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the floatarray a.
Array.iter2 ~f a b applies function f to all the elements of a and b.
map2 ~f a b applies function f to all the elements of a and b, and builds a floatarray with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
val for_all : f:(float -> bool) -> t -> boolfor_all ~f [|a1; ...; an|] checks if all elements of the floatarray satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an).
val exists : f:(float -> bool) -> t -> boolexists f [|a1; ...; an|] checks if at least one element of the floatarray satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an).
val mem : float -> set:t -> boolmem a ~set is true if and only if there is an element of set that is structurally equal to a, i.e. there is an x in set such that compare a x = 0.
val mem_ieee : float -> set:t -> boolSame as mem, but uses IEEE equality instead of structural equality.
val sort : cmp:(float -> float -> int) -> t -> unitSort a floatarray in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see below for a complete specification). For example, Stdlib.compare is a suitable comparison function. After calling sort, the array is sorted in place in increasing order. sort is guaranteed to run in constant heap space and (at most) logarithmic stack space.
The current implementation uses Heap Sort. It runs in constant stack space.
Specification of the comparison function: Let a be the floatarray and cmp the comparison function. The following must be true for all x, y, z in a :
cmp x y > 0 if and only if cmp y x < 0cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0When sort returns, a contains the same elements as before, reordered in such a way that for all i and j valid indices of a :
cmp a.(i) a.(j) >= 0 if and only if i >= jval stable_sort : cmp:(float -> float -> int) -> t -> unitSame as sort, but the sorting algorithm is stable (i.e. elements that compare equal are kept in their original order) and not guaranteed to run in constant heap space.
The current implementation uses Merge Sort. It uses a temporary floatarray of length n/2, where n is the length of the floatarray. It is usually faster than the current implementation of sort.
val fast_sort : cmp:(float -> float -> int) -> t -> unitSame as sort or stable_sort, whichever is faster on typical input.
Iterate on the floatarray, in increasing order. Modifications of the floatarray during iteration will be reflected in the sequence.
Iterate on the floatarray, in increasing order, yielding indices along elements. Modifications of the floatarray during iteration will be reflected in the sequence.
val map_to_array : f:(float -> 'a) -> t -> 'a arraymap_to_array ~f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].
val map_from_array : f:('a -> float) -> 'a array -> tmap_from_array ~f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
Stdlib.FloatFloating-point arithmetic.
OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-point operations never raise an exception on overflow, underflow, division by zero, etc. Instead, special IEEE numbers are returned as appropriate, such as infinity for 1.0 /. 0.0, neg_infinity for -1.0 /. 0.0, and nan ('not a number') for 0.0 /. 0.0. These special numbers then propagate through floating-point computations as expected: for instance, 1.0 /. infinity is 0.0, basic arithmetic operations (+., -., *., /.) with nan as an argument return nan, ...
fma x y z returns x * y + z, with a best effort for computing this expression with a single rounding, using either hardware instructions (providing full IEEE compliance) or a software emulation.
On 64-bit Cygwin, 64-bit mingw-w64 and MSVC 2017 and earlier, this function may be emulated owing to known bugs on limitations on these platforms. Note: since software emulation of the fma is costly, make sure that you are using hardware fma support if performance matters.
rem a b returns the remainder of a with respect to b. The returned value is a -. n *. b, where n is the quotient a /. b rounded towards zero to an integer.
succ x returns the floating point number right after x i.e., the smallest floating-point number greater than x. See also next_after.
pred x returns the floating-point number right before x i.e., the greatest floating-point number smaller than x. See also next_after.
A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0. Stands for 'not a number'. Any floating-point operation with nan as argument returns nan as result. As for floating-point comparisons, =, <, <=, > and >= return false and <> returns true if one or both of their arguments is nan.
The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0.
is_finite x is true if and only if x is finite i.e., not infinite and not nan.
is_infinite x is true if and only if x is infinity or neg_infinity.
is_nan x is true if and only if x is not a number (see nan).
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan or falls outside the range of representable integers.
Convert the given string to a float. The string is read in decimal (by default) or in hexadecimal (marked by 0x or 0X). The format of decimal floating-point numbers is [-] dd.ddd (e|E) [+|-] dd , where d stands for a decimal digit. The format of hexadecimal floating-point numbers is [-] 0(x|X) hh.hhh (p|P) [+|-] dd , where h stands for an hexadecimal digit and d for a decimal digit. In both cases, at least one of the integer and fractional parts must be given; the exponent part is optional. The _ (underscore) character can appear anywhere in the string and is ignored. Depending on the execution platforms, other representations of floating-point numbers can be accepted, but should not be relied upon.
Return a string representation of a floating-point number.
This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see Printf.
This function is an alias for Stdlib.string_of_float.
type fpclass = fpclass = The five classes of floating-point numbers, as determined by the classify_float function.
val classify_float : float -> fpclassReturn the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
expm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.
log1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.
Arc cosine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between 0.0 and pi.
Arc sine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between -pi/2 and pi/2.
atan2 y x returns the arc tangent of y /. x. The signs of x and y are used to determine the quadrant of the result. Result is in radians and is between -pi and pi.
hypot x y returns sqrt(x *. x + y *. y), that is, the length of the hypotenuse of a right-angled triangle with sides of length x and y, or, equivalently, the distance of the point (x,y) to origin. If one of x or y is infinite, returns infinity even if the other is nan.
Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]. Result is in radians and is between 0.0 and inf.
Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]. Result is in radians and ranges over the entire real line.
Error function. The argument ranges over the entire real line. The result is always within [-1.0, 1.0].
Complementary error function (erfc x = 1 - erf x). The argument ranges over the entire real line. The result is always within [-1.0, 1.0].
trunc x rounds x to the nearest integer whose absolute value is less than or equal to x.
round x rounds x to the nearest integer with ties (fractional values of 0.5) rounded away from zero, regardless of the current rounding direction. If x is an integer, +0., -0., nan, or infinite, x itself is returned.
On 64-bit mingw-w64, this function may be emulated owing to a bug in the C runtime library (CRT) on this platform.
Round above to an integer value. ceil f returns the least integer value greater than or equal to f. The result is returned as a float.
Round below to an integer value. floor f returns the greatest integer value less than or equal to f. The result is returned as a float.
next_after x y returns the next representable floating-point value following x in the direction of y. More precisely, if y is greater (resp. less) than x, it returns the smallest (resp. largest) representable number greater (resp. less) than x. If x equals y, the function returns y. If x or y is nan, a nan is returned. Note that next_after max_float infinity = infinity and that next_after 0. infinity is the smallest denormalized positive number. If x is the smallest denormalized positive number, next_after x 0. = 0.
copy_sign x y returns a float whose absolute value is that of x and whose sign is that of y. If x is nan, returns nan. If y is nan, returns either x or -. x, but it is not specified which.
sign_bit x is true if and only if the sign bit of x is set. For example sign_bit 1. and signbit 0. are false while sign_bit (-1.) and sign_bit (-0.) are true.
frexp f returns the pair of the significant and the exponent of f. When f is zero, the significant x and the exponent n of f are equal to zero. When f is non-zero, they are defined by f = x *. 2 ** n and 0.5 <= x < 1.0.
compare x y returns 0 if x is equal to y, a negative integer if x is less than y, and a positive integer if x is greater than y. compare treats nan as equal to itself and less than any other float value. This treatment of nan ensures that compare defines a total ordering relation.
min x y returns the minimum of x and y. It returns nan when x or y is nan. Moreover min (-0.) (+0.) = -0.
max x y returns the maximum of x and y. It returns nan when x or y is nan. Moreover max (-0.) (+0.) = +0.
min_max x y is (min x y, max x y), just more efficient.
min_num x y returns the minimum of x and y treating nan as missing values. If both x and y are nan, nan is returned. Moreover min_num (-0.) (+0.) = -0.
max_num x y returns the maximum of x and y treating nan as missing values. If both x and y are nan nan is returned. Moreover max_num (-0.) (+0.) = +0.
min_max_num x y is (min_num x y, max_num x y), just more efficient. Note that in particular min_max_num x nan = (x, x) and min_max_num nan y = (y, y).
val hash : t -> intThe hash function for floating-point numbers.
module Array : sig ... endFloat arrays with packed representation.
module ArrayLabels : sig ... endFloat arrays with packed representation (labeled functions).
Stdlib.FormatPretty-printing.
This module implements a pretty-printing facility to format values within 'pretty-printing boxes' and 'semantic tags' combined with a set of printf-like functions. The pretty-printer splits lines at specified break hints, and indents lines according to the box structure. Similarly, semantic tags can be used to decouple text presentation from its contents.
This pretty-printing facility is implemented as an overlay on top of abstract formatters which provide basic output functions. Some formatters are predefined, notably:
std_formatter outputs to stdouterr_formatter outputs to stderrMost functions in the Format module come in two variants: a short version that operates on std_formatter and the generic version prefixed by pp_ that takes a formatter as its first argument.
More formatters can be created with formatter_of_out_channel, formatter_of_buffer, formatter_of_symbolic_output_buffer or using custom formatters.
You may consider this module as providing an extension to the printf facility to provide automatic line splitting. The addition of pretty-printing annotations to your regular printf format strings gives you fancy indentation and line breaks. Pretty-printing annotations are described below in the documentation of the function Format.fprintf.
You may also use the explicit pretty-printing box management and printing functions provided by this module. This style is more basic but more verbose than the concise fprintf format strings.
For instance, the sequence open_box 0; print_string "x ="; print_space ();
+ print_int 1; close_box (); print_newline () that prints x = 1 within a pretty-printing box, can be abbreviated as printf "@[%s@ %i@]@." "x =" 1, or even shorter printf "@[x =@ %i@]@." 1.
Rule of thumb for casual users of this library:
open_box 0);print_cut () that outputs a simple break hint, or by print_space () that outputs a space indicating a break hint;print_int and print_string);close_box () to close the box;print_newline ().The behavior of pretty-printing commands is unspecified if there is no open pretty-printing box. Each box opened by one of the open_ functions below must be closed using close_box for proper formatting. Otherwise, some of the material printed in the boxes may not be output, or may be formatted incorrectly.
In case of interactive use, each phrase is executed in the initial state of the standard pretty-printer: after each phrase execution, the interactive system closes all open pretty-printing boxes, flushes all pending text, and resets the standard pretty-printer.
Warning: mixing calls to pretty-printing functions of this module with calls to Stdlib low level output functions is error prone.
The pretty-printing functions output material that is delayed in the pretty-printer queue and stacks in order to compute proper line splitting. In contrast, basic I/O output functions write directly in their output device. As a consequence, the output of a basic I/O function may appear before the output of a pretty-printing function that has been called before. For instance,
+ Stdlib.print_string "<";
+ Format.print_string "PRETTY";
+ Stdlib.print_string ">";
+ Format.print_string "TEXT";
+ leads to output <>PRETTYTEXT.
Abstract data corresponding to a pretty-printer (also called a formatter) and all its machinery. See also Defining formatters.
The pretty-printing engine uses the concepts of pretty-printing box and break hint to drive indentation and line splitting behavior of the pretty-printer.
Each different pretty-printing box kind introduces a specific line splitting policy:
Note that line splitting policy is box specific: the policy of a box does not rule the policy of inner boxes. For instance, if a vertical box is nested in an horizontal box, all break hints within the vertical box will split the line.
Moreover, opening a box after the maximum indentation limit splits the line whether or not the box would end up fitting on the line.
val pp_open_box : formatter -> int -> unitpp_open_box ppf d opens a new compacting pretty-printing box with offset d in the formatter ppf.
Within this box, the pretty-printer prints as much as possible material on every line.
A break hint splits the line if there is no more room on the line to print the remainder of the box.
Within this box, the pretty-printer emphasizes the box structure: if a structural box does not fit fully on a simple line, a break hint also splits the line if the splitting ``moves to the left'' (i.e. the new line gets an indentation smaller than the one of the current line).
This box is the general purpose pretty-printing box.
If the pretty-printer splits the line in the box, offset d is added to the current indentation.
val pp_close_box : formatter -> unit -> unitval pp_open_hbox : formatter -> unit -> unitpp_open_hbox ppf () opens a new 'horizontal' pretty-printing box.
This box prints material on a single line.
Break hints in a horizontal box never split the line. (Line splitting may still occur inside boxes nested deeper).
val pp_open_vbox : formatter -> int -> unitpp_open_vbox ppf d opens a new 'vertical' pretty-printing box with offset d.
This box prints material on as many lines as break hints in the box.
Every break hint in a vertical box splits the line.
If the pretty-printer splits the line in the box, d is added to the current indentation.
val pp_open_hvbox : formatter -> int -> unitpp_open_hvbox ppf d opens a new 'horizontal/vertical' pretty-printing box with offset d.
This box behaves as an horizontal box if it fits on a single line, otherwise it behaves as a vertical box.
If the pretty-printer splits the line in the box, d is added to the current indentation.
val pp_open_hovbox : formatter -> int -> unitpp_open_hovbox ppf d opens a new 'horizontal-or-vertical' pretty-printing box with offset d.
This box prints material as much as possible on every line.
A break hint splits the line if there is no more room on the line to print the remainder of the box.
If the pretty-printer splits the line in the box, d is added to the current indentation.
val pp_print_string : formatter -> string -> unitval pp_print_bytes : formatter -> bytes -> unitval pp_print_as : formatter -> int -> string -> unitpp_print_as ppf len s prints s in the current pretty-printing box. The pretty-printer formats s as if it were of length len.
val pp_print_int : formatter -> int -> unitval pp_print_float : formatter -> float -> unitval pp_print_char : formatter -> char -> unitval pp_print_bool : formatter -> bool -> unitA 'break hint' tells the pretty-printer to output some space or split the line whichever way is more appropriate to the current pretty-printing box splitting rules.
Break hints are used to separate printing items and are mandatory to let the pretty-printer correctly split lines and indent items.
Simple break hints are:
Note: the notions of space and line splitting are abstract for the pretty-printing engine, since those notions can be completely redefined by the programmer. However, in the pretty-printer default setting, ``output a space'' simply means printing a space character (ASCII code 32) and ``split the line'' means printing a newline character (ASCII code 10).
val pp_print_space : formatter -> unit -> unitpp_print_space ppf () emits a 'space' break hint: the pretty-printer may split the line at this point, otherwise it prints one space.
pp_print_space ppf () is equivalent to pp_print_break ppf 1 0.
val pp_print_cut : formatter -> unit -> unitpp_print_cut ppf () emits a 'cut' break hint: the pretty-printer may split the line at this point, otherwise it prints nothing.
pp_print_cut ppf () is equivalent to pp_print_break ppf 0 0.
val pp_print_break : formatter -> int -> int -> unitpp_print_break ppf nspaces offset emits a 'full' break hint: the pretty-printer may split the line at this point, otherwise it prints nspaces spaces.
If the pretty-printer splits the line, offset is added to the current indentation.
val pp_print_custom_break :
+ formatter ->
+ fits:(string * int * string) ->
+ breaks:(string * int * string) ->
+ unitpp_print_custom_break ppf ~fits:(s1, n, s2) ~breaks:(s3, m, s4) emits a custom break hint: the pretty-printer may split the line at this point.
If it does not split the line, then the s1 is emitted, then n spaces, then s2.
If it splits the line, then it emits the s3 string, then an indent (according to the box rules), then an offset of m spaces, then the s4 string.
While n and m are handled by formatter_out_functions.out_indent, the strings will be handled by formatter_out_functions.out_string. This allows for a custom formatter that handles indentation distinctly, for example, outputs <br/> tags or entities.
The custom break is useful if you want to change which visible (non-whitespace) characters are printed in case of break or no break. For example, when printing a list [a; b; c] , you might want to add a trailing semicolon when it is printed vertically:
[
+ a;
+ b;
+ c;
+]You can do this as follows:
printf "@[<v 0>[@;<0 2>@[<v 0>a;@,b;@,c@]%t]@]@\n"
+ (pp_print_custom_break ~fits:("", 0, "") ~breaks:(";", 0, ""))val pp_force_newline : formatter -> unit -> unitForce a new line in the current pretty-printing box.
The pretty-printer must split the line at this point,
Not the normal way of pretty-printing, since imperative line splitting may interfere with current line counters and box size calculation. Using break hints within an enclosing vertical box is a better alternative.
val pp_print_if_newline : formatter -> unit -> unitExecute the next formatting command if the preceding line has just been split. Otherwise, ignore the next formatting command.
val pp_print_flush : formatter -> unit -> unitEnd of pretty-printing: resets the pretty-printer to initial state.
All open pretty-printing boxes are closed, all pending text is printed. In addition, the pretty-printer low level output device is flushed to ensure that all pending text is really displayed.
Note: never use print_flush in the normal course of a pretty-printing routine, since the pretty-printer uses a complex buffering machinery to properly indent the output; manually flushing those buffers at random would conflict with the pretty-printer strategy and result to poor rendering.
Only consider using print_flush when displaying all pending material is mandatory (for instance in case of interactive use when you want the user to read some text) and when resetting the pretty-printer state will not disturb further pretty-printing.
Warning: If the output device of the pretty-printer is an output channel, repeated calls to print_flush means repeated calls to Stdlib.flush to flush the out channel; these explicit flush calls could foil the buffering strategy of output channels and could dramatically impact efficiency.
val pp_print_newline : formatter -> unit -> unitEnd of pretty-printing: resets the pretty-printer to initial state.
All open pretty-printing boxes are closed, all pending text is printed.
Equivalent to print_flush followed by a new line. See corresponding words of caution for print_flush.
Note: this is not the normal way to output a new line; the preferred method is using break hints within a vertical pretty-printing box.
val pp_set_margin : formatter -> int -> unitpp_set_margin ppf d sets the right margin to d (in characters): the pretty-printer splits lines that overflow the right margin according to the break hints given. Setting the margin to d means that the formatting engine aims at printing at most d-1 characters per line. Nothing happens if d is smaller than 2. If d is too large, the right margin is set to the maximum admissible value (which is greater than 10 ^ 9). If d is less than the current maximum indentation limit, the maximum indentation limit is decreased while trying to preserve a minimal ratio max_indent/margin>=50% and if possible the current difference margin - max_indent.
See also pp_set_geometry.
val pp_get_margin : formatter -> unit -> intval pp_set_max_indent : formatter -> int -> unitpp_set_max_indent ppf d sets the maximum indentation limit of lines to d (in characters): once this limit is reached, new pretty-printing boxes are rejected to the left, unless the enclosing box fully fits on the current line. As an illustration,
set_margin 10; set_max_indent 5; printf "@[123456@[7@]89A@]@." yields
123456
+789Abecause the nested box "@[7@]" is opened after the maximum indentation limit (7>5) and its parent box does not fit on the current line. Either decreasing the length of the parent box to make it fit on a line:
printf "@[123456@[7@]89@]@." or opening an intermediary box before the maximum indentation limit which fits on the current line
printf "@[123@[456@[7@]89@]A@]@." avoids the rejection to the left of the inner boxes and print respectively "123456789" and "123456789A" . Note also that vertical boxes never fit on a line whereas horizontal boxes always fully fit on the current line. Opening a box may split a line whereas the contents may have fit. If this behavior is problematic, it can be curtailed by setting the maximum indentation limit to margin - 1. Note that setting the maximum indentation limit to margin is invalid.
Nothing happens if d is smaller than 2.
If d is too large, the limit is set to the maximum admissible value (which is greater than 10 ^ 9).
If d is greater or equal than the current margin, it is ignored, and the current maximum indentation limit is kept.
See also pp_set_geometry.
val pp_get_max_indent : formatter -> unit -> intGeometric functions can be used to manipulate simultaneously the coupled variables, margin and maxixum indentation limit.
val check_geometry : geometry -> boolCheck if the formatter geometry is valid: 1 < max_indent < margin
val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unitval pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unitpp_set_geometry ppf ~max_indent ~margin sets both the margin and maximum indentation limit for ppf.
When 1 < max_indent < margin, pp_set_geometry ppf ~max_indent ~margin is equivalent to pp_set_margin ppf margin; pp_set_max_indent ppf max_indent; and avoids the subtly incorrect pp_set_max_indent ppf max_indent; pp_set_margin ppf margin;
Outside of this domain, pp_set_geometry raises an invalid argument exception whereas pp_safe_set_geometry does nothing.
pp_update_geometry ppf (fun geo -> { geo with ... }) lets you update a formatter's geometry in a way that is robust to extension of the geometry record with new fields.
Raises an invalid argument exception if the returned geometry does not satisfy check_geometry.
val get_geometry : unit -> geometryReturn the current geometry of the formatter
The maximum formatting depth is the maximum number of pretty-printing boxes simultaneously open.
Material inside boxes nested deeper is printed as an ellipsis (more precisely as the text returned by get_ellipsis_text ()).
val pp_set_max_boxes : formatter -> int -> unitpp_set_max_boxes ppf max sets the maximum number of pretty-printing boxes simultaneously open.
Material inside boxes nested deeper is printed as an ellipsis (more precisely as the text returned by get_ellipsis_text ()).
Nothing happens if max is smaller than 2.
val pp_get_max_boxes : formatter -> unit -> intReturns the maximum number of pretty-printing boxes allowed before ellipsis.
val pp_over_max_boxes : formatter -> unit -> boolTests if the maximum number of pretty-printing boxes allowed have already been opened.
A tabulation box prints material on lines divided into cells of fixed length. A tabulation box provides a simple way to display vertical columns of left adjusted text.
This box features command set_tab to define cell boundaries, and command print_tab to move from cell to cell and split the line when there is no more cells to print on the line.
Note: printing within tabulation box is line directed, so arbitrary line splitting inside a tabulation box leads to poor rendering. Yet, controlled use of tabulation boxes allows simple printing of columns within module Format.
val pp_open_tbox : formatter -> unit -> unitopen_tbox () opens a new tabulation box.
This box prints lines separated into cells of fixed width.
Inside a tabulation box, special tabulation markers defines points of interest on the line (for instance to delimit cell boundaries). Function Format.set_tab sets a tabulation marker at insertion point.
A tabulation box features specific tabulation breaks to move to next tabulation marker or split the line. Function Format.print_tbreak prints a tabulation break.
val pp_close_tbox : formatter -> unit -> unitval pp_set_tab : formatter -> unit -> unitval pp_print_tab : formatter -> unit -> unitprint_tab () emits a 'next' tabulation break hint: if not already set on a tabulation marker, the insertion point moves to the first tabulation marker on the right, or the pretty-printer splits the line and insertion point moves to the leftmost tabulation marker.
It is equivalent to print_tbreak 0 0.
val pp_print_tbreak : formatter -> int -> int -> unitprint_tbreak nspaces offset emits a 'full' tabulation break hint.
If not already set on a tabulation marker, the insertion point moves to the first tabulation marker on the right and the pretty-printer prints nspaces spaces.
If there is no next tabulation marker on the right, the pretty-printer splits the line at this point, then insertion point moves to the leftmost tabulation marker of the box.
If the pretty-printer splits the line, offset is added to the current indentation.
val pp_set_ellipsis_text : formatter -> string -> unitSet the text of the ellipsis printed when too many pretty-printing boxes are open (a single dot, ., by default).
val pp_get_ellipsis_text : formatter -> unit -> stringSemantic tags (or simply tags) are user's defined annotations to associate user's specific operations to printed entities.
Common usage of semantic tags is text decoration to get specific font or text size rendering for a display device, or marking delimitation of entities (e.g. HTML or TeX elements or terminal escape sequences). More sophisticated usage of semantic tags could handle dynamic modification of the pretty-printer behavior to properly print the material within some specific tags. For instance, we can define an RGB tag like so:
type stag += RGB of {r:int;g:int;b:int}In order to properly delimit printed entities, a semantic tag must be opened before and closed after the entity. Semantic tags must be properly nested like parentheses using pp_open_stag and pp_close_stag.
Tag specific operations occur any time a tag is opened or closed, At each occurrence, two kinds of operations are performed tag-marking and tag-printing:
Roughly speaking, tag-marking is commonly used to get a better rendering of texts in the rendering device, while tag-printing allows fine tuning of printing routines to print the same entity differently according to the semantic tags (i.e. print additional material or even omit parts of the output).
More precisely: when a semantic tag is opened or closed then both and successive 'tag-printing' and 'tag-marking' operations occur:
print_open_stag (resp. print_close_stag) with the name of the tag as argument: that tag-printing function can then print any regular material to the formatter (so that this material is enqueued as usual in the formatter queue for further line splitting computation).mark_open_stag (resp. mark_close_stag) with the name of the tag as argument: that tag-marking function can then return the 'tag-opening marker' (resp. `tag-closing marker') for direct output into the output device of the formatter.Being written directly into the output device of the formatter, semantic tag marker strings are not considered as part of the printing material that drives line splitting (in other words, the length of the strings corresponding to tag markers is considered as zero for line splitting).
Thus, semantic tag handling is in some sense transparent to pretty-printing and does not interfere with usual indentation. Hence, a single pretty-printing routine can output both simple 'verbatim' material or richer decorated output depending on the treatment of tags. By default, tags are not active, hence the output is not decorated with tag information. Once set_tags is set to true, the pretty-printer engine honors tags and decorates the output accordingly.
Default tag-marking functions behave the HTML way: string tags are enclosed in "<" and ">" while other tags are ignored; hence, opening marker for tag string "t" is "<t>" and closing marker is "</t>".
Default tag-printing functions just do nothing.
Tag-marking and tag-printing functions are user definable and can be set by calling set_formatter_stag_functions.
Semantic tag operations may be set on or off with set_tags. Tag-marking operations may be set on or off with set_mark_tags. Tag-printing operations may be set on or off with set_print_tags.
val open_stag : stag -> unitpp_open_stag ppf t opens the semantic tag named t.
The print_open_stag tag-printing function of the formatter is called with t as argument; then the opening tag marker for t, as given by mark_open_stag t, is written into the output device of the formatter.
val pp_close_stag : formatter -> unit -> unitpp_close_stag ppf () closes the most recently opened semantic tag t.
The closing tag marker, as given by mark_close_stag t, is written into the output device of the formatter; then the print_close_stag tag-printing function of the formatter is called with t as argument.
val pp_set_tags : formatter -> bool -> unitpp_set_tags ppf b turns on or off the treatment of semantic tags (default is off).
val pp_set_print_tags : formatter -> bool -> unitpp_set_print_tags ppf b turns on or off the tag-printing operations.
val pp_set_mark_tags : formatter -> bool -> unitval pp_get_print_tags : formatter -> unit -> boolval pp_get_mark_tags : formatter -> unit -> boolval pp_set_formatter_out_channel : formatter -> out_channel -> unitRedirecting the standard formatter output
val set_formatter_out_channel : out_channel -> unitRedirect the standard pretty-printer output to the given channel. (All the output functions of the standard formatter are set to the default output functions printing to the given channel.)
set_formatter_out_channel is equivalent to pp_set_formatter_out_channel std_formatter.
val pp_set_formatter_output_functions :
+ formatter ->
+ (string -> int -> int -> unit) ->
+ (unit -> unit) ->
+ unitpp_set_formatter_output_functions ppf out flush redirects the standard pretty-printer output functions to the functions out and flush.
The out function performs all the pretty-printer string output. It is called with a string s, a start position p, and a number of characters n; it is supposed to output characters p to p + n - 1 of s.
The flush function is called whenever the pretty-printer is flushed (via conversion %!, or pretty-printing indications @? or @., or using low level functions print_flush or print_newline).
val pp_get_formatter_output_functions :
+ formatter ->
+ unit ->
+ (string -> int -> int -> unit) * (unit -> unit)Return the current output functions of the standard pretty-printer.
The Format module is versatile enough to let you completely redefine the meaning of pretty-printing output: you may provide your own functions to define how to handle indentation, line splitting, and even printing of all the characters that have to be printed!
type formatter_out_functions = {out_string : string -> int -> int -> unit;out_flush : unit -> unit;out_newline : unit -> unit;out_spaces : int -> unit;out_indent : int -> unit;}The set of output functions specific to a formatter:
out_string function performs all the pretty-printer string output. It is called with a string s, a start position p, and a number of characters n; it is supposed to output characters p to p + n - 1 of s.out_flush function flushes the pretty-printer output device.out_newline is called to open a new line when the pretty-printer splits the line.out_spaces function outputs spaces when a break hint leads to spaces instead of a line split. It is called with the number of spaces to output.out_indent function performs new line indentation when the pretty-printer splits the line. It is called with the indentation value of the new line.By default:
out_string and out_flush are output device specific; (e.g. Stdlib.output_string and Stdlib.flush for a Stdlib.out_channel device, or Buffer.add_substring and Stdlib.ignore for a Buffer.t output device),out_newline is equivalent to out_string "\n" 0 1;out_spaces and out_indent are equivalent to out_string (String.make n ' ') 0 n.val pp_set_formatter_out_functions :
+ formatter ->
+ formatter_out_functions ->
+ unitval set_formatter_out_functions : formatter_out_functions -> unitpp_set_formatter_out_functions ppf out_funs Set all the pretty-printer output functions of ppf to those of argument out_funs,
This way, you can change the meaning of indentation (which can be something else than just printing space characters) and the meaning of new lines opening (which can be connected to any other action needed by the application at hand).
Reasonable defaults for functions out_spaces and out_newline are respectively out_funs.out_string (String.make n ' ') 0 n and out_funs.out_string "\n" 0 1.
val pp_get_formatter_out_functions :
+ formatter ->
+ unit ->
+ formatter_out_functionsval get_formatter_out_functions : unit -> formatter_out_functionsReturn the current output functions of the pretty-printer, including line splitting and indentation functions. Useful to record the current setting and restore it afterwards.
type formatter_stag_functions = {mark_open_stag : stag -> string;mark_close_stag : stag -> string;print_open_stag : stag -> unit;print_close_stag : stag -> unit;}The semantic tag handling functions specific to a formatter: mark versions are the 'tag-marking' functions that associate a string marker to a tag in order for the pretty-printing engine to write those markers as 0 length tokens in the output device of the formatter. print versions are the 'tag-printing' functions that can perform regular printing when a tag is closed or opened.
val pp_set_formatter_stag_functions :
+ formatter ->
+ formatter_stag_functions ->
+ unitval set_formatter_stag_functions : formatter_stag_functions -> unitpp_set_formatter_stag_functions ppf tag_funs changes the meaning of opening and closing semantic tag operations to use the functions in tag_funs when printing on ppf.
When opening a semantic tag with name t, the string t is passed to the opening tag-marking function (the mark_open_stag field of the record tag_funs), that must return the opening tag marker for that name. When the next call to close_stag () happens, the semantic tag name t is sent back to the closing tag-marking function (the mark_close_stag field of record tag_funs), that must return a closing tag marker for that name.
The print_ field of the record contains the tag-printing functions that are called at tag opening and tag closing time, to output regular material in the pretty-printer queue.
val pp_get_formatter_stag_functions :
+ formatter ->
+ unit ->
+ formatter_stag_functionsval get_formatter_stag_functions : unit -> formatter_stag_functionsReturn the current semantic tag operation functions of the standard pretty-printer.
Defining new formatters permits unrelated output of material in parallel on several output devices. All the parameters of a formatter are local to the formatter: right margin, maximum indentation limit, maximum number of pretty-printing boxes simultaneously open, ellipsis, and so on, are specific to each formatter and may be fixed independently.
For instance, given a Buffer.t buffer b, formatter_of_buffer b returns a new formatter using buffer b as its output device. Similarly, given a Stdlib.out_channel output channel oc, formatter_of_out_channel oc returns a new formatter using channel oc as its output device.
Alternatively, given out_funs, a complete set of output functions for a formatter, then formatter_of_out_functions out_funs computes a new formatter using those functions for output.
val formatter_of_out_channel : out_channel -> formatterformatter_of_out_channel oc returns a new formatter writing to the corresponding output channel oc.
val std_formatter : formatterThe standard formatter to write to standard output.
It is defined as formatter_of_out_channel Stdlib.stdout.
val err_formatter : formatterA formatter to write to standard error.
It is defined as formatter_of_out_channel Stdlib.stderr.
formatter_of_buffer b returns a new formatter writing to buffer b. At the end of pretty-printing, the formatter must be flushed using pp_print_flush or pp_print_newline, to print all the pending material into the buffer.
val stdbuf : Buffer.tThe string buffer in which str_formatter writes.
val str_formatter : formatterA formatter to output to the stdbuf string buffer.
str_formatter is defined as formatter_of_buffer stdbuf.
Returns the material printed with str_formatter, flushes the formatter and resets the corresponding buffer.
val make_formatter :
+ (string -> int -> int -> unit) ->
+ (unit -> unit) ->
+ formattermake_formatter out flush returns a new formatter that outputs with function out, and flushes with function flush.
For instance,
make_formatter
+ (Stdlib.output oc)
+ (fun () -> Stdlib.flush oc)returns a formatter to the Stdlib.out_channel oc.
val formatter_of_out_functions : formatter_out_functions -> formatterformatter_of_out_functions out_funs returns a new formatter that writes with the set of output functions out_funs.
See definition of type formatter_out_functions for the meaning of argument out_funs.
Symbolic pretty-printing is pretty-printing using a symbolic formatter, i.e. a formatter that outputs symbolic pretty-printing items.
When using a symbolic formatter, all regular pretty-printing activities occur but output material is symbolic and stored in a buffer of output items. At the end of pretty-printing, flushing the output buffer allows post-processing of symbolic output before performing low level output operations.
In practice, first define a symbolic output buffer b using:
let sob = make_symbolic_output_buffer (). Then define a symbolic formatter with:let ppf = formatter_of_symbolic_output_buffer sobUse symbolic formatter ppf as usual, and retrieve symbolic items at end of pretty-printing by flushing symbolic output buffer sob with:
flush_symbolic_output_buffer sob.type symbolic_output_item = | Output_flushsymbolic flush command
*)| Output_newlinesymbolic newline command
*)| Output_string of stringOutput_string s: symbolic output for string s
| Output_spaces of intOutput_spaces n: symbolic command to output n spaces
| Output_indent of intOutput_indent i: symbolic indentation of size i
Items produced by symbolic pretty-printers
val make_symbolic_output_buffer : unit -> symbolic_output_buffermake_symbolic_output_buffer () returns a fresh buffer for symbolic output.
val clear_symbolic_output_buffer : symbolic_output_buffer -> unitclear_symbolic_output_buffer sob resets buffer sob.
val get_symbolic_output_buffer :
+ symbolic_output_buffer ->
+ symbolic_output_item listget_symbolic_output_buffer sob returns the contents of buffer sob.
val flush_symbolic_output_buffer :
+ symbolic_output_buffer ->
+ symbolic_output_item listflush_symbolic_output_buffer sob returns the contents of buffer sob and resets buffer sob. flush_symbolic_output_buffer sob is equivalent to let items = get_symbolic_output_buffer sob in
+ clear_symbolic_output_buffer sob; items
val add_symbolic_output_item :
+ symbolic_output_buffer ->
+ symbolic_output_item ->
+ unitadd_symbolic_output_item sob itm adds item itm to buffer sob.
val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatterformatter_of_symbolic_output_buffer sob returns a symbolic formatter that outputs to symbolic_output_buffer sob.
val pp_print_list :
+ ?pp_sep:(formatter -> unit -> unit) ->
+ (formatter -> 'a -> unit) ->
+ formatter ->
+ 'a list ->
+ unitpp_print_list ?pp_sep pp_v ppf l prints items of list l, using pp_v to print each item, and calling pp_sep between items (pp_sep defaults to pp_print_cut. Does nothing on empty lists.
val pp_print_seq :
+ ?pp_sep:(formatter -> unit -> unit) ->
+ (formatter -> 'a -> unit) ->
+ formatter ->
+ 'a Seq.t ->
+ unitpp_print_seq ?pp_sep pp_v ppf s prints items of sequence s, using pp_v to print each item, and calling pp_sep between items (pp_sep defaults to pp_print_cut. Does nothing on empty sequences.
This function does not terminate on infinite sequences.
val pp_print_text : formatter -> string -> unitpp_print_text ppf s prints s with spaces and newlines respectively printed using pp_print_space and pp_force_newline.
val pp_print_option :
+ ?none:(formatter -> unit -> unit) ->
+ (formatter -> 'a -> unit) ->
+ formatter ->
+ 'a option ->
+ unitpp_print_option ?none pp_v ppf o prints o on ppf using pp_v if o is Some v and none if it is None. none prints nothing by default.
val pp_print_result :
+ ok:(formatter -> 'a -> unit) ->
+ error:(formatter -> 'e -> unit) ->
+ formatter ->
+ ('a, 'e) result ->
+ unitpp_print_result ~ok ~error ppf r prints r on ppf using ok if r is Ok _ and error if r is Error _.
val pp_print_either :
+ left:(formatter -> 'a -> unit) ->
+ right:(formatter -> 'b -> unit) ->
+ formatter ->
+ ('a, 'b) Either.t ->
+ unitpp_print_either ~left ~right ppf e prints e on ppf using left if e is Either.Left _ and right if e is Either.Right _.
Module Format provides a complete set of printf like functions for pretty-printing using format string specifications.
Specific annotations may be added in the format strings to give pretty-printing commands to the pretty-printing engine.
Those annotations are introduced in the format strings using the @ character. For instance, @ means a space break, @, means a cut, @[ opens a new box, and @] closes the last open box.
fprintf ff fmt arg1 ... argN formats the arguments arg1 to argN according to the format string fmt, and outputs the resulting string on the formatter ff.
The format string fmt is a character string which contains three types of objects: plain characters and conversion specifications as specified in the Printf module, and pretty-printing indications specific to the Format module.
The pretty-printing indication characters are introduced by a @ character, and their meanings are:
@[: open a pretty-printing box. The type and offset of the box may be optionally specified with the following syntax: the < character, followed by an optional box type indication, then an optional integer offset, and the closing > character. Pretty-printing box type is one of h, v, hv, b, or hov. 'h' stands for an 'horizontal' pretty-printing box, 'v' stands for a 'vertical' pretty-printing box, 'hv' stands for an 'horizontal/vertical' pretty-printing box, 'b' stands for an 'horizontal-or-vertical' pretty-printing box demonstrating indentation, 'hov' stands a simple 'horizontal-or-vertical' pretty-printing box. For instance, @[<hov 2> opens an 'horizontal-or-vertical' pretty-printing box with indentation 2 as obtained with open_hovbox 2. For more details about pretty-printing boxes, see the various box opening functions open_*box.@]: close the most recently opened pretty-printing box.@,: output a 'cut' break hint, as with print_cut ().@ : output a 'space' break hint, as with print_space ().@;: output a 'full' break hint as with print_break. The nspaces and offset parameters of the break hint may be optionally specified with the following syntax: the < character, followed by an integer nspaces value, then an integer offset, and a closing > character. If no parameters are provided, the good break defaults to a 'space' break hint.@.: flush the pretty-printer and split the line, as with print_newline ().@<n>: print the following item as if it were of length n. Hence, printf "@<0>%s" arg prints arg as a zero length string. If @<n> is not followed by a conversion specification, then the following character of the format is printed as if it were of length n.@\{: open a semantic tag. The name of the tag may be optionally specified with the following syntax: the < character, followed by an optional string specification, and the closing > character. The string specification is any character string that does not contain the closing character '>'. If omitted, the tag name defaults to the empty string. For more details about semantic tags, see the functions open_stag and close_stag.@\}: close the most recently opened semantic tag.@?: flush the pretty-printer as with print_flush (). This is equivalent to the conversion %!.@\n: force a newline, as with force_newline (), not the normal way of pretty-printing, you should prefer using break hints inside a vertical pretty-printing box.Note: To prevent the interpretation of a @ character as a pretty-printing indication, escape it with a % character. Old quotation mode @@ is deprecated since it is not compatible with formatted input interpretation of character '@'.
Example: printf "@[%s@ %d@]@." "x =" 1 is equivalent to open_box (); print_string "x ="; print_space ();
+ print_int 1; close_box (); print_newline (). It prints x = 1 within a pretty-printing 'horizontal-or-vertical' box.
val sprintf : ('a, unit, string) format -> 'aSame as printf above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments. Note that the pretty-printer queue is flushed at the end of each call to sprintf.
In case of multiple and related calls to sprintf to output material on a single string, you should consider using fprintf with the predefined formatter str_formatter and call flush_str_formatter () to get the final result.
Alternatively, you can use Format.fprintf with a formatter writing to a buffer of your own: flushing the formatter and the buffer at the end of pretty-printing returns the desired string.
Same as printf above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments. The type of asprintf is general enough to interact nicely with %a conversions.
Same as fprintf, except the formatter is the last argument. dprintf "..." a b c is a function of type formatter -> unit which can be given to a format specifier %t.
This can be used as a replacement for asprintf to delay formatting decisions. Using the string returned by asprintf in a formatting context forces formatting decisions to be taken in isolation, and the final string may be created prematurely. dprintf allows delay of formatting decisions until the final formatting context is known. For example:
let t = Format.dprintf "%i@ %i@ %i" 1 2 3 in
+...
+Format.printf "@[<v>%t@]" tSame as fprintf above, but does not print anything. Useful to ignore some material when conditionally printing.
Formatted Pretty-Printing with continuations.
Same as fprintf above, but instead of returning immediately, passes the formatter to its first argument at the end of printing.
Same as dprintf above, but instead of returning immediately, passes the suspended printer to its first argument at the end of printing.
Same as kfprintf above, but does not print anything. Useful to ignore some material when conditionally printing.
val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'bSame as sprintf above, but instead of returning the string, passes it to the first argument.
Same as asprintf above, but instead of returning the string, passes it to the first argument.
val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'bval set_all_formatter_output_functions :
+ out:(string -> int -> int -> unit) ->
+ flush:(unit -> unit) ->
+ newline:(unit -> unit) ->
+ spaces:(int -> unit) ->
+ unitval get_all_formatter_output_functions :
+ unit ->
+ (string ->
+ int ->
+ int ->
+ unit)
+ * (unit ->
+ unit)
+ * (unit ->
+ unit)
+ * (int ->
+ unit)val pp_set_all_formatter_output_functions :
+ formatter ->
+ out:(string -> int -> int -> unit) ->
+ flush:(unit -> unit) ->
+ newline:(unit -> unit) ->
+ spaces:(int -> unit) ->
+ unitval pp_get_all_formatter_output_functions :
+ formatter ->
+ unit ->
+ (string ->
+ int ->
+ int ->
+ unit)
+ * (unit ->
+ unit)
+ * (unit ->
+ unit)
+ * (int ->
+ unit)val open_tag : tag -> unitval pp_close_tag : formatter -> unit -> unittype formatter_tag_functions = {mark_open_tag : tag -> string;mark_close_tag : tag -> string;print_open_tag : tag -> unit;print_close_tag : tag -> unit;}val pp_set_formatter_tag_functions :
+ formatter ->
+ formatter_tag_functions ->
+ unitThis function will erase non-string tag formatting functions.
val set_formatter_tag_functions : formatter_tag_functions -> unitval pp_get_formatter_tag_functions :
+ formatter ->
+ unit ->
+ formatter_tag_functionsval get_formatter_tag_functions : unit -> formatter_tag_functionsStdlib.FunFunction manipulation.
const c is a function that always returns the value c. For any argument x, (const c) x is c.
flip f reverses the argument order of the binary function f. For any arguments x and y, (flip f) x y is f y x.
negate p is the negation of the predicate function p. For any argument x, (negate p) x is not (p x).
protect ~finally work invokes work () and then finally () before work () returns with its value or an exception. In the latter case the exception is re-raised after finally (). If finally () raises an exception, then the exception Finally_raised is raised instead.
protect can be used to enforce local invariants whether work () returns normally or raises an exception. However, it does not protect against unexpected exceptions raised inside finally () such as Stdlib.Out_of_memory, Stdlib.Stack_overflow, or asynchronous exceptions raised by signal handlers (e.g. Sys.Break).
Note: It is a programming error if other kinds of exceptions are raised by finally, as any exception raised in work () will be lost in the event of a Finally_raised exception. Therefore, one should make sure to handle those inside the finally.
Finally_raised exn is raised by protect ~finally work when finally raises an exception exn. This exception denotes either an unexpected exception or a programming error. As a general rule, one should not catch a Finally_raised exception except as part of a catch-all handler.
Gc.MemprofMemprof is a sampling engine for allocated memory words. Every allocated word has a probability of being sampled equal to a configurable sampling rate. Once a block is sampled, it becomes tracked. A tracked block triggers a user-defined callback as soon as it is allocated, promoted or deallocated.
Since blocks are composed of several words, a block can potentially be sampled several times. If a block is sampled several times, then each of the callback is called once for each event of this block: the multiplicity is given in the n_samples field of the allocation structure.
This engine makes it possible to implement a low-overhead memory profiler as an OCaml library.
Note: this API is EXPERIMENTAL. It may change without prior notice.
type allocation = private {n_samples : int;The number of samples in this block (>= 1).
*)size : int;The size of the block, in words, excluding the header.
*)source : allocation_source;The type of the allocation.
*)callstack : Printexc.raw_backtrace;The callstack for the allocation.
*)}The type of metadata associated with allocations. This is the type of records passed to the callback triggered by the sampling of an allocation.
type ('minor, 'major) tracker = {alloc_minor : allocation -> 'minor option;alloc_major : allocation -> 'major option;promote : 'minor -> 'major option;dealloc_minor : 'minor -> unit;dealloc_major : 'major -> unit;}A ('minor, 'major) tracker describes how memprof should track sampled blocks over their lifetime, keeping a user-defined piece of metadata for each of them: 'minor is the type of metadata to keep for minor blocks, and 'major the type of metadata for major blocks.
When using threads, it is guaranteed that allocation callbacks are always run in the thread where the allocation takes place.
If an allocation-tracking or promotion-tracking function returns None, memprof stops tracking the corresponding value.
val null_tracker : ('minor, 'major) trackerDefault callbacks simply return None or ()
val start :
+ sampling_rate:float ->
+ ?callstack_size:int ->
+ ('minor, 'major) tracker ->
+ unitStart the sampling with the given parameters. Fails if sampling is already active.
The parameter sampling_rate is the sampling rate in samples per word (including headers). Usually, with cheap callbacks, a rate of 1e-4 has no visible effect on performance, and 1e-3 causes the program to run a few percent slower
The parameter callstack_size is the length of the callstack recorded at every sample. Its default is max_int.
The parameter tracker determines how to track sampled blocks over their lifetime in the minor and major heap.
Sampling is temporarily disabled when calling a callback for the current thread. So they do not need to be re-entrant if the program is single-threaded. However, if threads are used, it is possible that a context switch occurs during a callback, in this case the callback functions must be re-entrant.
Note that the callback can be postponed slightly after the actual event. The callstack passed to the callback is always accurate, but the program state may have evolved.
Stop the sampling. Fails if sampling is not active.
This function does not allocate memory.
All the already tracked blocks are discarded. If there are pending postponed callbacks, they may be discarded.
Calling stop when a callback is running can lead to callbacks not being called even though some events happened.
Stdlib.GcMemory management control and statistics; finalised values.
type stat = {minor_words : float;Number of words allocated in the minor heap since the program was started.
*)promoted_words : float;Number of words allocated in the minor heap that survived a minor collection and were moved to the major heap since the program was started.
*)major_words : float;Number of words allocated in the major heap, including the promoted words, since the program was started.
*)minor_collections : int;Number of minor collections since the program was started.
*)major_collections : int;Number of major collection cycles completed since the program was started.
*)heap_words : int;Total size of the major heap, in words.
*)heap_chunks : int;Number of contiguous pieces of memory that make up the major heap.
*)live_words : int;Number of words of live data in the major heap, including the header words.
Note that "live" words refers to every word in the major heap that isn't currently known to be collectable, which includes words that have become unreachable by the program after the start of the previous gc cycle. It is typically much simpler and more predictable to call Gc.full_major (or Gc.compact) then computing gc stats, as then "live" words has the simple meaning of "reachable by the program". One caveat is that a single call to Gc.full_major will not reclaim values that have a finaliser from Gc.finalise (this does not apply to Gc.finalise_last). If this caveat matters, simply call Gc.full_major twice instead of once.
live_blocks : int;Number of live blocks in the major heap.
See live_words for a caveat about what "live" means.
free_words : int;Number of words in the free list.
*)free_blocks : int;Number of blocks in the free list.
*)largest_free : int;Size (in words) of the largest block in the free list.
*)fragments : int;Number of wasted words due to fragmentation. These are 1-words free blocks placed between two live blocks. They are not available for allocation.
*)compactions : int;Number of heap compactions since the program was started.
*)top_heap_words : int;Maximum size reached by the major heap, in words.
*)stack_size : int;Current size of the stack, in words.
*)forced_major_collections : int;Number of forced full major collections completed since the program was started.
*)}The memory management counters are returned in a stat record.
The total amount of memory allocated by the program since it was started is (in words) minor_words + major_words - promoted_words. Multiply by the word size (4 on a 32-bit machine, 8 on a 64-bit machine) to get the number of bytes.
type control = {mutable minor_heap_size : int;The size (in words) of the minor heap. Changing this parameter will trigger a minor collection. Default: 256k.
*)mutable major_heap_increment : int;How much to add to the major heap when increasing it. If this number is less than or equal to 1000, it is a percentage of the current heap size (i.e. setting it to 100 will double the heap size at each increase). If it is more than 1000, it is a fixed number of words that will be added to the heap. Default: 15.
*)mutable space_overhead : int;The major GC speed is computed from this parameter. This is the memory that will be "wasted" because the GC does not immediately collect unreachable blocks. It is expressed as a percentage of the memory used for live data. The GC will work more (use more CPU time and collect blocks more eagerly) if space_overhead is smaller. Default: 120.
mutable verbose : int;This value controls the GC messages on standard error output. It is a sum of some of the following flags, to print messages on the corresponding events:
0x001 Start and end of major GC cycle.0x002 Minor collection and major GC slice.0x004 Growing and shrinking of the heap.0x008 Resizing of stacks and memory manager tables.0x010 Heap compaction.0x020 Change of GC parameters.0x040 Computation of major GC slice size.0x080 Calling of finalisation functions.0x100 Bytecode executable and shared library search at start-up.0x200 Computation of compaction-triggering condition.0x400 Output GC statistics at program exit. Default: 0.mutable max_overhead : int;Heap compaction is triggered when the estimated amount of "wasted" memory is more than max_overhead percent of the amount of live data. If max_overhead is set to 0, heap compaction is triggered at the end of each major GC cycle (this setting is intended for testing purposes only). If max_overhead >= 1000000, compaction is never triggered. If compaction is permanently disabled, it is strongly suggested to set allocation_policy to 2. Default: 500.
mutable stack_limit : int;The maximum size of the stack (in words). This is only relevant to the byte-code runtime, as the native code runtime uses the operating system's stack. Default: 1024k.
*)mutable allocation_policy : int;The policy used for allocating in the major heap. Possible values are 0, 1 and 2.
The default is best-fit.
On one example that was known to be bad for next-fit and first-fit, next-fit takes 28s using 855Mio of memory, first-fit takes 47s using 566Mio of memory, best-fit takes 27s using 545Mio of memory.
Note: If you change to next-fit, you may need to reduce the space_overhead setting, for example using 80 instead of the default 120 which is tuned for best-fit. Otherwise, your program will need more memory.
Note: changing the allocation policy at run-time forces a heap compaction, which is a lengthy operation unless the heap is small (e.g. at the start of the program).
Default: 2.
*)window_size : int;The size of the window used by the major GC for smoothing out variations in its workload. This is an integer between 1 and 50. Default: 1.
*)custom_major_ratio : int;Target ratio of floating garbage to major heap size for out-of-heap memory held by custom values located in the major heap. The GC speed is adjusted to try to use this much memory for dead values that are not yet collected. Expressed as a percentage of major heap size. The default value keeps the out-of-heap floating garbage about the same size as the in-heap overhead. Note: this only applies to values allocated with caml_alloc_custom_mem (e.g. bigarrays). Default: 44.
custom_minor_ratio : int;Bound on floating garbage for out-of-heap memory held by custom values in the minor heap. A minor GC is triggered when this much memory is held by custom values located in the minor heap. Expressed as a percentage of minor heap size. Note: this only applies to values allocated with caml_alloc_custom_mem (e.g. bigarrays). Default: 100.
custom_minor_max_size : int;Maximum amount of out-of-heap memory for each custom value allocated in the minor heap. When a custom value is allocated on the minor heap and holds more than this many bytes, only this value is counted against custom_minor_ratio and the rest is directly counted against custom_major_ratio. Note: this only applies to values allocated with caml_alloc_custom_mem (e.g. bigarrays). Default: 8192 bytes.
}The GC parameters are given as a control record. Note that these parameters can also be initialised by setting the OCAMLRUNPARAM environment variable. See the documentation of ocamlrun.
val stat : unit -> statReturn the current values of the memory management counters in a stat record. This function examines every heap block to get the statistics.
val quick_stat : unit -> statSame as stat except that live_words, live_blocks, free_words, free_blocks, largest_free, and fragments are set to 0. This function is much faster than stat because it does not need to go through the heap.
Return (minor_words, promoted_words, major_words). This function is as fast as quick_stat.
Number of words allocated in the minor heap since the program was started. This number is accurate in byte-code programs, but only an approximation in programs compiled to native code.
In native code this function does not allocate.
val get : unit -> controlReturn the current values of the GC parameters in a control record.
val set : control -> unitset r changes the GC parameters according to the control record r. The normal usage is: Gc.set { (Gc.get()) with Gc.verbose = 0x00d }
major_slice n Do a minor collection and a slice of major collection. n is the size of the slice: the GC will do enough work to free (on average) n words of memory. If n = 0, the GC will try to do enough work to ensure that the next automatic slice has no work to do. This function returns an unspecified integer (currently: 0).
Do a minor collection, finish the current major collection cycle, and perform a complete new cycle. This will collect all currently unreachable blocks.
Perform a full major collection and compact the heap. Note that heap compaction is a lengthy operation.
val print_stat : out_channel -> unitPrint the current values of the memory management counters (in human-readable form) into the channel argument.
Return the total number of bytes allocated since the program was started. It is returned as a float to avoid overflow problems with int on 32-bit machines.
get_bucket n returns the current size of the n-th future bucket of the GC smoothing system. The unit is one millionth of a full GC.
get_credit () returns the current size of the "work done in advance" counter of the GC smoothing system. The unit is one millionth of a full GC.
Return the number of times we tried to map huge pages and had to fall back to small pages. This is always 0 if OCAMLRUNPARAM contains H=1.
finalise f v registers f as a finalisation function for v. v must be heap-allocated. f will be called with v as argument at some point between the first time v becomes unreachable (including through weak pointers) and the time v is collected by the GC. Several functions can be registered for the same value, or even several instances of the same function. Each instance will be called once (or never, if the program terminates before v becomes unreachable).
The GC will call the finalisation functions in the order of deallocation. When several values become unreachable at the same time (i.e. during the same GC cycle), the finalisation functions will be called in the reverse order of the corresponding calls to finalise. If finalise is called in the same order as the values are allocated, that means each value is finalised before the values it depends upon. Of course, this becomes false if additional dependencies are introduced by assignments.
In the presence of multiple OCaml threads it should be assumed that any particular finaliser may be executed in any of the threads.
Anything reachable from the closure of finalisation functions is considered reachable, so the following code will not work as expected:
let v = ... in Gc.finalise (fun _ -> ...v...) v Instead you should make sure that v is not in the closure of the finalisation function by writing:
let f = fun x -> ... let v = ... in Gc.finalise f v The f function can use all features of OCaml, including assignments that make the value reachable again. It can also loop forever (in this case, the other finalisation functions will not be called during the execution of f, unless it calls finalise_release). It can call finalise on v or other values to register other functions or even itself. It can raise an exception; in this case the exception will interrupt whatever the program was doing when the function was called.
finalise will raise Invalid_argument if v is not guaranteed to be heap-allocated. Some examples of values that are not heap-allocated are integers, constant constructors, booleans, the empty array, the empty list, the unit value. The exact list of what is heap-allocated or not is implementation-dependent. Some constant values can be heap-allocated but never deallocated during the lifetime of the program, for example a list of integer constants; this is also implementation-dependent. Note that values of types float are sometimes allocated and sometimes not, so finalising them is unsafe, and finalise will also raise Invalid_argument for them. Values of type 'a Lazy.t (for any 'a) are like float in this respect, except that the compiler sometimes optimizes them in a way that prevents finalise from detecting them. In this case, it will not raise Invalid_argument, but you should still avoid calling finalise on lazy values.
The results of calling String.make, Bytes.make, Bytes.create, Array.make, and Stdlib.ref are guaranteed to be heap-allocated and non-constant except when the length argument is 0.
same as finalise except the value is not given as argument. So you can't use the given value for the computation of the finalisation function. The benefit is that the function is called after the value is unreachable for the last time instead of the first time. So contrary to finalise the value will never be reachable again or used again. In particular every weak pointer and ephemeron that contained this value as key or data is unset before running the finalisation function. Moreover the finalisation functions attached with finalise are always called before the finalisation functions attached with finalise_last.
A finalisation function may call finalise_release to tell the GC that it can launch the next finalisation function without waiting for the current one to return.
An alarm is a piece of data that calls a user function at the end of each major GC cycle. The following functions are provided to create and delete alarms.
val create_alarm : (unit -> unit) -> alarmcreate_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one. A value of type alarm is returned that you can use to call delete_alarm.
val delete_alarm : alarm -> unitdelete_alarm a will stop the calls to the function associated to a. Calling delete_alarm a again has no effect.
eventlog_pause () will pause the collection of traces in the runtime. Traces are collected if the program is linked to the instrumented runtime and started with the environment variable OCAML_EVENTLOG_ENABLED. Events are flushed to disk after pausing, and no new events will be recorded until eventlog_resume is called.
eventlog_resume () will resume the collection of traces in the runtime. Traces are collected if the program is linked to the instrumented runtime and started with the environment variable OCAML_EVENTLOG_ENABLED. This call can be used after calling eventlog_pause, or if the program was started with OCAML_EVENTLOG_ENABLED=p. (which pauses the collection of traces before the first event.)
module Memprof : sig ... endMemprof is a sampling engine for allocated memory words. Every allocated word has a probability of being sampled equal to a configurable sampling rate. Once a block is sampled, it becomes tracked. A tracked block triggers a user-defined callback as soon as it is allocated, promoted or deallocated.
Stdlib.GenlexA generic lexical analyzer.
This module implements a simple 'standard' lexical analyzer, presented as a function from character streams to token streams. It implements roughly the lexical conventions of OCaml, but is parameterized by the set of keywords of your language.
Example: a lexer suitable for a desk calculator is obtained by
let lexer = make_lexer ["+"; "-"; "*"; "/"; "let"; "="; "("; ")"]The associated parser would be a function from token stream to, for instance, int, and would have rules such as:
let rec parse_expr = parser
+ | [< n1 = parse_atom; n2 = parse_remainder n1 >] -> n2
+and parse_atom = parser
+ | [< 'Int n >] -> n
+ | [< 'Kwd "("; n = parse_expr; 'Kwd ")" >] -> n
+and parse_remainder n1 = parser
+ | [< 'Kwd "+"; n2 = parse_expr >] -> n1 + n2
+ | [< >] -> n1One should notice that the use of the parser keyword and associated notation for streams are only available through camlp4 extensions. This means that one has to preprocess its sources e. g. by using the "-pp" command-line switch of the compilers.
The type of tokens. The lexical classes are: Int and Float for integer and floating-point numbers; String for string literals, enclosed in double quotes; Char for character literals, enclosed in single quotes; Ident for identifiers (either sequences of letters, digits, underscores and quotes, or sequences of 'operator characters' such as +, *, etc); and Kwd for keywords (either identifiers or single 'special characters' such as (, }, etc).
Construct the lexer function. The first argument is the list of keywords. An identifier s is returned as Kwd s if s belongs to this list, and as Ident s otherwise. A special character s is returned as Kwd s if s belongs to this list, and cause a lexical error (exception Stream.Error with the offending lexeme as its parameter) otherwise. Blanks and newlines are skipped. Comments delimited by (* and *) are skipped as well, and can be nested. A Stream.Failure exception is raised if end of stream is unexpectedly reached.
Make.Hval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Hashtbl.MakeFunctor building an implementation of the hashtable structure. The functor Hashtbl.Make returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the hashing and equality functions specified in the functor argument H instead of generic equality and hashing. Since the hash function is not seeded, the create operation of the result structure always returns non-randomized hash tables.
module H : HashedTypetype key = H.tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsMakeSeeded.Hval hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
Hashtbl.MakeSeededFunctor building an implementation of the hashtable structure. The functor Hashtbl.MakeSeeded returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the seeded hashing and equality functions specified in the functor argument H instead of generic equality and hashing. The create operation of the result structure supports the ~random optional parameter and returns randomized hash tables if ~random:true is passed or if randomization is globally on (see Hashtbl.randomize).
module H : SeededHashedTypetype key = H.tval create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsStdlib.HashtblHash tables and hash functions.
Hash tables are hashed association tables, with in-place modification.
val create : ?random:bool -> int -> ('a, 'b) tHashtbl.create n creates a new, empty hash table, with initial size n. For best results, n should be on the order of the expected number of elements that will be in the table. The table grows as needed, so n is just an initial guess.
The optional ~random parameter (a boolean) controls whether the internal organization of the hash table is randomized at each execution of Hashtbl.create or deterministic over all executions.
A hash table that is created with ~random set to false uses a fixed hash function (hash) to distribute keys among buckets. As a consequence, collisions between keys happen deterministically. In Web-facing applications or other security-sensitive applications, the deterministic collision patterns can be exploited by a malicious user to create a denial-of-service attack: the attacker sends input crafted to create many collisions in the table, slowing the application down.
A hash table that is created with ~random set to true uses the seeded hash function seeded_hash with a seed that is randomly chosen at hash table creation time. In effect, the hash function used is randomly selected among 2^{30} different hash functions. All these hash functions have different collision patterns, rendering ineffective the denial-of-service attack described above. However, because of randomization, enumerating all elements of the hash table using fold or iter is no longer deterministic: elements are enumerated in different orders at different runs of the program.
If no ~random parameter is given, hash tables are created in non-random mode by default. This default can be changed either programmatically by calling randomize or by setting the R flag in the OCAMLRUNPARAM environment variable.
val clear : ('a, 'b) t -> unitEmpty a hash table. Use reset instead of clear to shrink the size of the bucket table to its initial size.
val reset : ('a, 'b) t -> unitEmpty a hash table and shrink the size of the bucket table to its initial size.
val add : ('a, 'b) t -> 'a -> 'b -> unitHashtbl.add tbl key data adds a binding of key to data in table tbl. Previous bindings for key are not removed, but simply hidden. That is, after performing remove tbl key, the previous binding for key, if any, is restored. (Same behavior as with association lists.)
val find : ('a, 'b) t -> 'a -> 'bHashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
val find_opt : ('a, 'b) t -> 'a -> 'b optionHashtbl.find_opt tbl x returns the current binding of x in tbl, or None if no such binding exists.
val find_all : ('a, 'b) t -> 'a -> 'b listHashtbl.find_all tbl x returns the list of all data associated with x in tbl. The current binding is returned first, then the previous bindings, in reverse order of introduction in the table.
val mem : ('a, 'b) t -> 'a -> boolHashtbl.mem tbl x checks if x is bound in tbl.
val remove : ('a, 'b) t -> 'a -> unitHashtbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists. It does nothing if x is not bound in tbl.
val replace : ('a, 'b) t -> 'a -> 'b -> unitval iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unitHashtbl.iter f tbl applies f to all bindings in table tbl. f receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to f.
The order in which the bindings are passed to f is unspecified. However, if the table contains several bindings for the same key, they are passed to f in reverse order of introduction, that is, the most recent binding is passed first.
If the hash table was created in non-randomized mode, the order in which the bindings are enumerated is reproducible between successive runs of the program, and even between minor versions of OCaml. For randomized hash tables, the order of enumeration is entirely random.
The behavior is not specified if the hash table is modified by f during the iteration.
val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unitHashtbl.filter_map_inplace f tbl applies f to all bindings in table tbl and update each binding depending on the result of f. If f returns None, the binding is discarded. If it returns Some new_val, the binding is update to associate the key to new_val.
Other comments for iter apply as well.
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'cHashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values. Each binding is presented exactly once to f.
The order in which the bindings are passed to f is unspecified. However, if the table contains several bindings for the same key, they are passed to f in reverse order of introduction, that is, the most recent binding is passed first.
If the hash table was created in non-randomized mode, the order in which the bindings are enumerated is reproducible between successive runs of the program, and even between minor versions of OCaml. For randomized hash tables, the order of enumeration is entirely random.
The behavior is not specified if the hash table is modified by f during the iteration.
val length : ('a, 'b) t -> intHashtbl.length tbl returns the number of bindings in tbl. It takes constant time. Multiple bindings are counted once each, so Hashtbl.length gives the number of times Hashtbl.iter calls its first argument.
After a call to Hashtbl.randomize(), hash tables are created in randomized mode by default: create returns randomized hash tables, unless the ~random:false optional parameter is given. The same effect can be achieved by setting the R parameter in the OCAMLRUNPARAM environment variable.
It is recommended that applications or Web frameworks that need to protect themselves against the denial-of-service attack described in create call Hashtbl.randomize() at initialization time.
Note that once Hashtbl.randomize() was called, there is no way to revert to the non-randomized default behavior of create. This is intentional. Non-randomized hash tables can still be created using Hashtbl.create ~random:false.
Return true if the tables are currently created in randomized mode by default, false otherwise.
Return a copy of the given hashtable. Unlike copy, rebuild h re-hashes all the (key, value) entries of the original table h. The returned hash table is randomized if h was randomized, or the optional random parameter is true, or if the default is to create randomized hash tables; see create for more information.
rebuild can safely be used to import a hash table built by an old version of the Hashtbl module, then marshaled to persistent storage. After unmarshaling, apply rebuild to produce a hash table for the current version of the Hashtbl module.
type statistics = {num_bindings : int;num_buckets : int;Number of buckets in the table.
*)max_bucket_length : int;Maximal number of bindings per bucket.
*)bucket_histogram : int array;Histogram of bucket sizes. This array histo has length max_bucket_length + 1. The value of histo.(i) is the number of buckets whose size is i.
}val stats : ('a, 'b) t -> statisticsHashtbl.stats tbl returns statistics about the table tbl: number of buckets, size of the biggest bucket, distribution of buckets by size.
Iterate on the whole table. The order in which the bindings appear in the sequence is unspecified. However, if the table contains several bindings for the same key, they appear in reversed order of introduction, that is, the most recent binding appears first.
The behavior is not specified if the hash table is modified during the iteration.
Add the given bindings to the table, using replace
Build a table from the given bindings. The bindings are added in the same order they appear in the sequence, using replace_seq, which means that if two pairs have the same key, only the latest one will appear in the table.
The functorial interface allows the use of specific comparison and hash functions, either for performance/security concerns, or because keys are not hashable/comparable with the polymorphic builtins.
For instance, one might want to specialize a table for integer keys:
module IntHash =
+ struct
+ type t = int
+ let equal i j = i=j
+ let hash i = i land max_int
+ end
+
+module IntHashtbl = Hashtbl.Make(IntHash)
+
+let h = IntHashtbl.create 17 in
+IntHashtbl.add h 12 "hello"This creates a new module IntHashtbl, with a new type 'a
+ IntHashtbl.t of tables from int to 'a. In this example, h contains string values so its type is string IntHashtbl.t.
Note that the new type 'a IntHashtbl.t is not compatible with the type ('a,'b) Hashtbl.t of the generic interface. For example, Hashtbl.length h would not type-check, you must use IntHashtbl.length.
module type HashedType = sig ... endThe input signature of the functor Make.
Functor building an implementation of the hashtable structure. The functor Hashtbl.Make returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the hashing and equality functions specified in the functor argument H instead of generic equality and hashing. Since the hash function is not seeded, the create operation of the result structure always returns non-randomized hash tables.
module type SeededHashedType = sig ... endThe input signature of the functor MakeSeeded.
module type SeededS = sig ... endThe output signature of the functor MakeSeeded.
module MakeSeeded (H : SeededHashedType) : SeededS with type key = H.tFunctor building an implementation of the hashtable structure. The functor Hashtbl.MakeSeeded returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the seeded hashing and equality functions specified in the functor argument H instead of generic equality and hashing. The create operation of the result structure supports the ~random optional parameter and returns randomized hash tables if ~random:true is passed or if randomization is globally on (see Hashtbl.randomize).
Hashtbl.hash x associates a nonnegative integer to any value of any type. It is guaranteed that if x = y or Stdlib.compare x y = 0, then hash x = hash y. Moreover, hash always terminates, even on cyclic structures.
A variant of hash that is further parameterized by an integer seed.
Hashtbl.hash_param meaningful total x computes a hash value for x, with the same properties as for hash. The two extra integer parameters meaningful and total give more precise control over hashing. Hashing performs a breadth-first, left-to-right traversal of the structure x, stopping after meaningful meaningful nodes were encountered, or total nodes (meaningful or not) were encountered. If total as specified by the user exceeds a certain value, currently 256, then it is capped to that value. Meaningful nodes are: integers; floating-point numbers; strings; characters; booleans; and constant constructors. Larger values of meaningful and total means that more nodes are taken into account to compute the final hash value, and therefore collisions are less likely to happen. However, hashing takes longer. The parameters meaningful and total govern the tradeoff between accuracy and speed. As default choices, hash and seeded_hash take meaningful = 10 and total = 100.
A variant of hash_param that is further parameterized by an integer seed. Usage: Hashtbl.seeded_hash_param meaningful total seed x.
Hashtbl.HashedTypeThe input signature of the functor Make.
val hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Hashtbl.SThe output signature of the functor Make.
val create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsHashtbl.SeededHashedTypeThe input signature of the functor MakeSeeded.
val hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
Hashtbl.SeededSThe output signature of the functor MakeSeeded.
val create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsStdlib.In_channelInput channels.
type t = in_channelThe type of input channel.
type open_flag = open_flag = | Open_rdonlyopen for reading.
*)| Open_wronlyopen for writing.
*)| Open_appendopen for appending: always write at end of file.
*)| Open_creatcreate the file if it does not exist.
*)| Open_truncempty the file if it already exists.
*)| Open_exclfail if Open_creat and the file already exists.
*)| Open_binaryopen in binary mode (no conversion).
*)| Open_textopen in text mode (may perform conversions).
*)| Open_nonblockopen in non-blocking mode.
*)Opening modes for open_gen.
val stdin : tThe standard input for the process.
val open_bin : string -> tOpen the named file for reading, and return a new input channel on that file, positioned at the beginning of the file.
val open_text : string -> tval with_open_bin : string -> (t -> 'a) -> 'awith_open_bin fn f opens a channel ic on file fn and returns f
+ ic. After f returns, either with a value or by raising an exception, ic is guaranteed to be closed.
val with_open_text : string -> (t -> 'a) -> 'aLike with_open_bin, but the channel is opened in text mode (see open_text).
Like with_open_bin, but can specify the opening mode and file permission, in case the file must be created (see open_gen).
val seek : t -> int64 -> unitseek chan pos sets the current reading position to pos for channel chan. This works only for regular files. On files of other kinds, the behavior is unspecified.
val pos : t -> int64Return the current reading position for the given channel. For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos, then going back to this position using seek will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
val length : t -> int64Return the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless. The returned size does not take into account the end-of-line translations that can be performed when reading from a channel opened in text mode.
val close : t -> unitClose the given channel. Input functions raise a Sys_error exception when they are applied to a closed input channel, except close, which does nothing when applied to an already closed channel.
val input_char : t -> char optionRead one character from the given input channel. Returns None if there are no more characters to read.
val input_byte : t -> int optionSame as input_char, but return the 8-bit integer representing the character. Returns None if the end of file was reached.
val input_line : t -> string optioninput_line ic reads characters from ic until a newline or the end of file is reached. Returns the string of all characters read, without the newline (if any). Returns None if the end of the file has been reached. In particular, this will be the case if the last line of input is empty.
A newline is the character \n unless the file is open in text mode and Sys.win32 is true in which case it is the sequence of characters \r\n.
val input : t -> bytes -> int -> int -> intinput ic buf pos len reads up to len characters from the given channel ic, storing them in byte sequence buf, starting at character number pos. It returns the actual number of characters read, between 0 and len (inclusive). A return value of 0 means that the end of file was reached.
Use really_input to read exactly len characters.
val really_input : t -> bytes -> int -> int -> unit optionreally_input ic buf pos len reads len characters from channel ic, storing them in byte sequence buf, starting at character number pos.
Returns None if the end of file is reached before len characters have been read.
val really_input_string : t -> int -> string optionreally_input_string ic len reads len characters from channel ic and returns them in a new string. Returns None if the end of file is reached before len characters have been read.
val input_all : t -> stringinput_all ic reads all remaining data from ic.
val set_binary_mode : t -> bool -> unitset_binary_mode ic true sets the channel ic to binary mode: no translations take place during input.
set_binary_mode ic false sets the channel ic to text mode: depending on the operating system, some translations may take place during input. For instance, under Windows, end-of-lines will be translated from \r\n to \n.
This function has no effect under operating systems that do not distinguish between text mode and binary mode.
Stdlib.IntInteger values.
Integers are Sys.int_size bits wide and use two's complement representation. All operations are taken modulo 2Sys.int_size. They do not fail on overflow.
div x y is the division x / y. See Stdlib.(/) for details.
rem x y is the remainder x mod y. See Stdlib.(mod) for details.
abs x is the absolute value of x. That is x if x is positive and neg x if x is negative. Warning. This may be negative if the argument is min_int.
shift_left x n shifts x to the left by n bits. The result is unspecified if n < 0 or n > Sys.int_size.
shift_right x n shifts x to the right by n bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if n < 0 or n > Sys.int_size.
shift_right x n shifts x to the right by n bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if n < 0 or n > Sys.int_size.
compare x y is Stdlib.compare x y but more efficient.
of_float x truncates x to an integer. The result is unspecified if the argument is nan or falls outside the range of representable integers.
Stdlib.Int3232-bit integers.
This module provides operations on the type int32 of signed 32-bit integers. Unlike the built-in int type, the type int32 is guaranteed to be exactly 32-bit wide on all platforms. All arithmetic operations over int32 are taken modulo 232.
Performance notice: values of type int32 occupy more memory space than values of type int, and arithmetic operations on int32 are generally slower than those on int. Use int32 only when the application requires exact 32-bit arithmetic.
Literals for 32-bit integers are suffixed by l:
let zero: int32 = 0l
+let one: int32 = 1l
+let m_one: int32 = -1lInteger division. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/).
Same as div, except that arguments and result are interpreted as unsigned 32-bit integers.
Integer remainder. If y is not zero, the result of Int32.rem x y satisfies the following property: x = Int32.add (Int32.mul (Int32.div x y) y) (Int32.rem x y). If y = 0, Int32.rem x y raises Division_by_zero.
Same as rem, except that arguments and result are interpreted as unsigned 32-bit integers.
Int32.shift_left x y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= 32.
Int32.shift_right x y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= 32.
Int32.shift_right_logical x y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= 32.
Convert the given integer (type int) to a 32-bit integer (type int32). On 64-bit platforms, the argument is taken modulo 232.
Convert the given 32-bit integer (type int32) to an integer (type int). On 32-bit platforms, the 32-bit integer is taken modulo 231, i.e. the high-order bit is lost during the conversion. On 64-bit platforms, the conversion is exact.
Same as to_int, but interprets the argument as an unsigned integer. Returns None if the unsigned value of the argument cannot fit into an int.
Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0). If the truncated floating-point number is outside the range [Int32.min_int, Int32.max_int], no exception is raised, and an unspecified, platform-dependent integer is returned.
Convert the given string to a 32-bit integer. The string is read in decimal (by default, or if the string begins with 0u) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively.
The 0u prefix reads the input as an unsigned integer in the range [0, 2*Int32.max_int+1]. If the input exceeds Int32.max_int it is converted to the signed integer Int32.min_int + input - Int32.max_int - 1.
The _ (underscore) character can appear anywhere in the string and is ignored.
Return the internal representation of the given float according to the IEEE 754 floating-point 'single format' bit layout. Bit 31 of the result represents the sign of the float; bits 30 to 23 represent the (biased) exponent; bits 22 to 0 represent the mantissa.
Return the floating-point number whose internal representation, according to the IEEE 754 floating-point 'single format' bit layout, is the given int32.
The comparison function for 32-bit integers, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Int32 to be passed as argument to the functors Set.Make and Map.Make.
Same as compare, except that arguments are interpreted as unsigned 32-bit integers.
Stdlib.Int6464-bit integers.
This module provides operations on the type int64 of signed 64-bit integers. Unlike the built-in int type, the type int64 is guaranteed to be exactly 64-bit wide on all platforms. All arithmetic operations over int64 are taken modulo 264
Performance notice: values of type int64 occupy more memory space than values of type int, and arithmetic operations on int64 are generally slower than those on int. Use int64 only when the application requires exact 64-bit arithmetic.
Literals for 64-bit integers are suffixed by L:
let zero: int64 = 0L
+let one: int64 = 1L
+let m_one: int64 = -1LSame as div, except that arguments and result are interpreted as unsigned 64-bit integers.
Integer remainder. If y is not zero, the result of Int64.rem x y satisfies the following property: x = Int64.add (Int64.mul (Int64.div x y) y) (Int64.rem x y). If y = 0, Int64.rem x y raises Division_by_zero.
Same as rem, except that arguments and result are interpreted as unsigned 64-bit integers.
Int64.shift_left x y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= 64.
Int64.shift_right x y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= 64.
Int64.shift_right_logical x y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= 64.
Convert the given 64-bit integer (type int64) to an integer (type int). On 64-bit platforms, the 64-bit integer is taken modulo 263, i.e. the high-order bit is lost during the conversion. On 32-bit platforms, the 64-bit integer is taken modulo 231, i.e. the top 33 bits are lost during the conversion.
Same as to_int, but interprets the argument as an unsigned integer. Returns None if the unsigned value of the argument cannot fit into an int.
Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0). If the truncated floating-point number is outside the range [Int64.min_int, Int64.max_int], no exception is raised, and an unspecified, platform-dependent integer is returned.
Convert the given 32-bit integer (type int32) to a 64-bit integer (type int64).
Convert the given 64-bit integer (type int64) to a 32-bit integer (type int32). The 64-bit integer is taken modulo 232, i.e. the top 32 bits are lost during the conversion.
Convert the given native integer (type nativeint) to a 64-bit integer (type int64).
Convert the given 64-bit integer (type int64) to a native integer. On 32-bit platforms, the 64-bit integer is taken modulo 232. On 64-bit platforms, the conversion is exact.
Convert the given string to a 64-bit integer. The string is read in decimal (by default, or if the string begins with 0u) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively.
The 0u prefix reads the input as an unsigned integer in the range [0, 2*Int64.max_int+1]. If the input exceeds Int64.max_int it is converted to the signed integer Int64.min_int + input - Int64.max_int - 1.
The _ (underscore) character can appear anywhere in the string and is ignored.
Return the internal representation of the given float according to the IEEE 754 floating-point 'double format' bit layout. Bit 63 of the result represents the sign of the float; bits 62 to 52 represent the (biased) exponent; bits 51 to 0 represent the mantissa.
Return the floating-point number whose internal representation, according to the IEEE 754 floating-point 'double format' bit layout, is the given int64.
The comparison function for 64-bit integers, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Int64 to be passed as argument to the functors Set.Make and Map.Make.
Same as compare, except that arguments are interpreted as unsigned 64-bit integers.
Stdlib.LargeFileOperations on large files. This sub-module provides 64-bit variants of the channel functions that manipulate file positions and file sizes. By representing positions and sizes by 64-bit integers (type int64) instead of regular integers (type int), these alternate functions allow operating on files whose sizes are greater than max_int.
val seek_out : out_channel -> int64 -> unitval pos_out : out_channel -> int64val out_channel_length : out_channel -> int64val seek_in : in_channel -> int64 -> unitval pos_in : in_channel -> int64val in_channel_length : in_channel -> int64Stdlib.LazyDeferred computations.
type 'a t = 'a CamlinternalLazy.tA value of type 'a Lazy.t is a deferred computation, called a suspension, that has a result of type 'a. The special expression syntax lazy (expr) makes a suspension of the computation of expr, without computing expr itself yet. "Forcing" the suspension will then compute expr and return its result. Matching a suspension with the special pattern syntax lazy(pattern) also computes the underlying expression and tries to bind it to pattern:
let lazy_option_map f x =
+match x with
+| lazy (Some x) -> Some (Lazy.force f x)
+| _ -> NoneNote: If lazy patterns appear in multiple cases in a pattern-matching, lazy expressions may be forced even outside of the case ultimately selected by the pattern matching. In the example above, the suspension x is always computed.
Note: lazy_t is the built-in type constructor used by the compiler for the lazy keyword. You should not use it directly. Always use Lazy.t instead.
Note: Lazy.force is not thread-safe. If you use this module in a multi-threaded program, you will need to add some locks.
Note: if the program is compiled with the -rectypes option, ill-founded recursive definitions of the form let rec x = lazy x or let rec x = lazy(lazy(...(lazy x))) are accepted by the type-checker and lead, when forced, to ill-formed values that trigger infinite loops in the garbage collector and other parts of the run-time system. Without the -rectypes option, such ill-founded recursive definitions are rejected by the type-checker.
val force : 'a t -> 'aforce x forces the suspension x and returns its result. If x has already been forced, Lazy.force x returns the same value again without recomputing it. If it raised an exception, the same exception is raised again.
map f x returns a suspension that, when forced, forces x and applies f to its value.
It is equivalent to lazy (f (Lazy.force x)).
val is_val : 'a t -> boolis_val x returns true if x has already been forced and did not raise an exception.
val from_val : 'a -> 'a tfrom_val v evaluates v first (as any function would) and returns an already-forced suspension of its result. It is the same as let x = v in lazy x, but uses dynamic tests to optimize suspension creation in some cases.
map_val f x applies f directly if x is already forced, otherwise it behaves as map f x.
When x is already forced, this behavior saves the construction of a suspension, but on the other hand it performs more work eagerly that may not be useful if you never force the function result.
If f raises an exception, it will be raised immediately when is_val x, or raised only when forcing the thunk otherwise.
If map_val f x does not raise an exception, then is_val (map_val f x) is equal to is_val x.
The following definitions are for advanced uses only; they require familiary with the lazy compilation scheme to be used appropriately.
val from_fun : (unit -> 'a) -> 'a tfrom_fun f is the same as lazy (f ()) but slightly more efficient.
It should only be used if the function f is already defined. In particular it is always less efficient to write from_fun (fun () -> expr) than lazy expr.
val force_val : 'a t -> 'aforce_val x forces the suspension x and returns its result. If x has already been forced, force_val x returns the same value again without recomputing it.
If the computation of x raises an exception, it is unspecified whether force_val x raises the same exception or Undefined.
val lazy_from_fun : (unit -> 'a) -> 'a tval lazy_from_val : 'a -> 'a tval lazy_is_val : 'a t -> boolStdlib.LexingThe run-time library for lexers generated by ocamllex.
A value of type position describes a point in a source file. pos_fname is the file name; pos_lnum is the line number; pos_bol is the offset of the beginning of the line (number of characters between the beginning of the lexbuf and the beginning of the line); pos_cnum is the offset of the position (number of characters between the beginning of the lexbuf and the position). The difference between pos_cnum and pos_bol is the character offset within the line (i.e. the column number, assuming each character is one column wide).
See the documentation of type lexbuf for information about how the lexing engine will manage positions.
val dummy_pos : positionA value of type position, guaranteed to be different from any valid position.
type lexbuf = {refill_buff : lexbuf -> unit;mutable lex_buffer : bytes;mutable lex_buffer_len : int;mutable lex_abs_pos : int;mutable lex_start_pos : int;mutable lex_curr_pos : int;mutable lex_last_pos : int;mutable lex_last_action : int;mutable lex_eof_reached : bool;mutable lex_mem : int array;mutable lex_start_p : position;mutable lex_curr_p : position;}The type of lexer buffers. A lexer buffer is the argument passed to the scanning functions defined by the generated scanners. The lexer buffer holds the current state of the scanner, plus a function to refill the buffer from the input.
Lexers can optionally maintain the lex_curr_p and lex_start_p position fields. This "position tracking" mode is the default, and it corresponds to passing ~with_position:true to functions that create lexer buffers. In this mode, the lexing engine and lexer actions are co-responsible for properly updating the position fields, as described in the next paragraph. When the mode is explicitly disabled (with ~with_position:false), the lexing engine will not touch the position fields and the lexer actions should be careful not to do it either; the lex_curr_p and lex_start_p field will then always hold the dummy_pos invalid position. Not tracking positions avoids allocations and memory writes and can significantly improve the performance of the lexer in contexts where lex_start_p and lex_curr_p are not needed.
Position tracking mode works as follows. At each token, the lexing engine will copy lex_curr_p to lex_start_p, then change the pos_cnum field of lex_curr_p by updating it with the number of characters read since the start of the lexbuf. The other fields are left unchanged by the lexing engine. In order to keep them accurate, they must be initialised before the first use of the lexbuf, and updated by the relevant lexer actions (i.e. at each end of line -- see also new_line).
val from_channel : ?with_positions:bool -> in_channel -> lexbufCreate a lexer buffer on the given input channel. Lexing.from_channel inchan returns a lexer buffer which reads from the input channel inchan, at the current reading position.
val from_string : ?with_positions:bool -> string -> lexbufCreate a lexer buffer which reads from the given string. Reading starts from the first character in the string. An end-of-input condition is generated when the end of the string is reached.
val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbufCreate a lexer buffer with the given function as its reading method. When the scanner needs more characters, it will call the given function, giving it a byte sequence s and a byte count n. The function should put n bytes or fewer in s, starting at index 0, and return the number of bytes provided. A return value of 0 means end of input.
Set the initial tracked input position for lexbuf to a custom value. Ignores pos_fname. See set_filename for changing this field.
val set_filename : lexbuf -> string -> unitSet filename in the initial tracked position to file in lexbuf.
val with_positions : lexbuf -> boolTell whether the lexer buffer keeps track of position fields lex_curr_p / lex_start_p, as determined by the corresponding optional argument for functions that create lexer buffers (whose default value is true).
When with_positions is false, lexer actions should not modify position fields. Doing it nevertheless could re-enable the with_position mode and degrade performances.
The following functions can be called from the semantic actions of lexer definitions (the ML code enclosed in braces that computes the value returned by lexing functions). They give access to the character string matched by the regular expression associated with the semantic action. These functions must be applied to the argument lexbuf, which, in the code generated by ocamllex, is bound to the lexer buffer passed to the parsing function.
val lexeme : lexbuf -> stringLexing.lexeme lexbuf returns the string matched by the regular expression.
val lexeme_char : lexbuf -> int -> charLexing.lexeme_char lexbuf i returns character number i in the matched string.
val lexeme_start : lexbuf -> intLexing.lexeme_start lexbuf returns the offset in the input stream of the first character of the matched string. The first character of the stream has offset 0.
val lexeme_end : lexbuf -> intLexing.lexeme_end lexbuf returns the offset in the input stream of the character following the last character of the matched string. The first character of the stream has offset 0.
Like lexeme_start, but return a complete position instead of an offset. When position tracking is disabled, the function returns dummy_pos.
Like lexeme_end, but return a complete position instead of an offset. When position tracking is disabled, the function returns dummy_pos.
val new_line : lexbuf -> unitUpdate the lex_curr_p field of the lexbuf to reflect the start of a new line. You can call this function in the semantic action of the rule that matches the end-of-line character. The function does nothing when position tracking is disabled.
val flush_input : lexbuf -> unitDiscard the contents of the buffer and reset the current position to 0. The next use of the lexbuf will trigger a refill.
Stdlib.ListList operations.
Some functions are flagged as not tail-recursive. A tail-recursive function uses constant stack space, while a non-tail-recursive function uses stack space proportional to the length of its list argument, which can be a problem with very long lists. When the function takes several list arguments, an approximate formula giving stack usage (in some unspecified constant unit) is shown in parentheses.
The above considerations can usually be ignored if your lists are not longer than about 10000 elements.
The labeled version of this module can be used as described in the StdLabels module.
Compare the lengths of two lists. compare_lengths l1 l2 is equivalent to compare (length l1) (length l2), except that the computation stops after reaching the end of the shortest list.
Compare the length of a list to an integer. compare_length_with l len is equivalent to compare (length l) len, except that the computation stops after at most len iterations on the list.
Return the n-th element of the given list. The first element (head of the list) is at position 0.
Return the n-th element of the given list. The first element (head of the list) is at position 0. Return None if the list is too short.
init len f is f 0; f 1; ...; f (len-1), evaluated left to right.
Concatenate two lists. Same function as the infix operator @. Not tail-recursive (length of the first argument). The @ operator is not tail-recursive either.
rev_append l1 l2 reverses l1 and concatenates it with l2. This is equivalent to (rev l1) @ l2, but rev_append is tail-recursive and more efficient.
Concatenate a list of lists. The elements of the argument are all concatenated together (in the same order) to give the result. Not tail-recursive (length of the argument + length of the longest sub-list).
Same as concat. Not tail-recursive (length of the argument + length of the longest sub-list).
equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.
Note: the eq function may be called even if the lists have different length. If you know your equality function is costly, you may want to check compare_lengths first.
compare cmp [a1; ...; an] [b1; ...; bm] performs a lexicographic comparison of the two input lists, using the same 'a -> 'a -> int interface as Stdlib.compare:
a1 :: l1 is smaller than a2 :: l2 (negative result) if a1 is smaller than a2, or if they are equal (0 result) and l1 is smaller than l2[] is strictly smaller than non-empty listsNote: the cmp function will be called even if the lists have different lengths.
iter f [a1; ...; an] applies function f in turn to a1; ...; an. It is equivalent to begin f a1; f a2; ...; f an; () end.
Same as iter, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
map f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f. Not tail-recursive.
Same as map, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. Not tail-recursive.
filter_map f l applies f to every element of l, filters out the None elements and returns the list of the arguments of the Some elements.
fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.
fold_left f init [b1; ...; bn] is f (... (f (f init b1) b2) ...) bn.
fold_right f [a1; ...; an] init is f a1 (f a2 (... (f an init) ...)). Not tail-recursive.
iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
map2 f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].
fold_left2 f init [a1; ...; an] [b1; ...; bn] is f (... (f (f init a1 b1) a2 b2) ...) an bn.
fold_right2 f [a1; ...; an] [b1; ...; bn] init is f a1 b1 (f a2 b2 (... (f an bn init) ...)).
for_all f [a1; ...; an] checks if all elements of the list satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an) for a non-empty list and true if the list is empty.
exists f [a1; ...; an] checks if at least one element of the list satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an) for a non-empty list and false if the list is empty.
Same as for_all, but for a two-argument predicate.
Same as exists, but for a two-argument predicate.
Same as mem, but uses physical equality instead of structural equality to compare list elements.
find f l returns the first element of the list l that satisfies the predicate f.
find f l returns the first element of the list l that satisfies the predicate f. Returns None if there is no value that satisfies f in the list l.
find_map f l applies f to the elements of l in order, and returns the first result of the form Some v, or None if none exist.
filter f l returns all the elements of the list l that satisfy the predicate f. The order of the elements in the input list is preserved.
find_all is another name for filter.
Same as filter, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
partition f l returns a pair of lists (l1, l2), where l1 is the list of all the elements of l that satisfy the predicate f, and l2 is the list of all the elements of l that do not satisfy f. The order of the elements in the input list is preserved.
val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c listpartition_map f l returns a pair of lists (l1, l2) such that, for each element x of the input list l:
f x is Left y1, then y1 is in l1, andf x is Right y2, then y2 is in l2.The output elements are included in l1 and l2 in the same relative order as the corresponding input elements in l.
In particular, partition_map (fun x -> if f x then Left x else Right x) l is equivalent to partition f l.
assoc a l returns the value associated with key a in the list of pairs l. That is, assoc a [ ...; (a,b); ...] = b if (a,b) is the leftmost binding of a in list l.
assoc_opt a l returns the value associated with key a in the list of pairs l. That is, assoc_opt a [ ...; (a,b); ...] = Some b if (a,b) is the leftmost binding of a in list l. Returns None if there is no value associated with a in the list l.
Same as assoc, but uses physical equality instead of structural equality to compare keys.
Same as assoc_opt, but uses physical equality instead of structural equality to compare keys.
Same as assoc, but simply return true if a binding exists, and false if no bindings exist for the given key.
Same as mem_assoc, but uses physical equality instead of structural equality to compare keys.
remove_assoc a l returns the list of pairs l without the first pair with key a, if any. Not tail-recursive.
Same as remove_assoc, but uses physical equality instead of structural equality to compare keys. Not tail-recursive.
Transform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]). Not tail-recursive.
Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
Sort a list in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see Array.sort for a complete specification). For example, Stdlib.compare is a suitable comparison function. The resulting list is sorted in increasing order. sort is guaranteed to run in constant heap space (in addition to the size of the result list) and logarithmic stack space.
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
Same as sort, but the sorting algorithm is guaranteed to be stable (i.e. elements that compare equal are kept in their original order).
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
Same as sort or stable_sort, whichever is faster on typical input.
Same as sort, but also remove duplicates.
Merge two lists: Assuming that l1 and l2 are sorted according to the comparison function cmp, merge cmp l1 l2 will return a sorted list containing all the elements of l1 and l2. If several elements compare equal, the elements of l1 will be before the elements of l2. Not tail-recursive (sum of the lengths of the arguments).
val to_seq : 'a list -> 'a Seq.tIterate on the list.
val of_seq : 'a Seq.t -> 'a listCreate a list from a sequence.
Stdlib.ListLabelsList operations.
Some functions are flagged as not tail-recursive. A tail-recursive function uses constant stack space, while a non-tail-recursive function uses stack space proportional to the length of its list argument, which can be a problem with very long lists. When the function takes several list arguments, an approximate formula giving stack usage (in some unspecified constant unit) is shown in parentheses.
The above considerations can usually be ignored if your lists are not longer than about 10000 elements.
The labeled version of this module can be used as described in the StdLabels module.
Compare the lengths of two lists. compare_lengths l1 l2 is equivalent to compare (length l1) (length l2), except that the computation stops after reaching the end of the shortest list.
Compare the length of a list to an integer. compare_length_with l len is equivalent to compare (length l) len, except that the computation stops after at most len iterations on the list.
Return the n-th element of the given list. The first element (head of the list) is at position 0.
Return the n-th element of the given list. The first element (head of the list) is at position 0. Return None if the list is too short.
init ~len ~f is f 0; f 1; ...; f (len-1), evaluated left to right.
Concatenate two lists. Same function as the infix operator @. Not tail-recursive (length of the first argument). The @ operator is not tail-recursive either.
rev_append l1 l2 reverses l1 and concatenates it with l2. This is equivalent to (rev l1) @ l2, but rev_append is tail-recursive and more efficient.
Concatenate a list of lists. The elements of the argument are all concatenated together (in the same order) to give the result. Not tail-recursive (length of the argument + length of the longest sub-list).
Same as concat. Not tail-recursive (length of the argument + length of the longest sub-list).
equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.
Note: the eq function may be called even if the lists have different length. If you know your equality function is costly, you may want to check compare_lengths first.
compare cmp [a1; ...; an] [b1; ...; bm] performs a lexicographic comparison of the two input lists, using the same 'a -> 'a -> int interface as Stdlib.compare:
a1 :: l1 is smaller than a2 :: l2 (negative result) if a1 is smaller than a2, or if they are equal (0 result) and l1 is smaller than l2[] is strictly smaller than non-empty listsNote: the cmp function will be called even if the lists have different lengths.
iter ~f [a1; ...; an] applies function f in turn to a1; ...; an. It is equivalent to begin f a1; f a2; ...; f an; () end.
Same as iter, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
map ~f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f. Not tail-recursive.
Same as map, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. Not tail-recursive.
filter_map ~f l applies f to every element of l, filters out the None elements and returns the list of the arguments of the Some elements.
fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.
fold_left ~f ~init [b1; ...; bn] is f (... (f (f init b1) b2) ...) bn.
fold_right ~f [a1; ...; an] ~init is f a1 (f a2 (... (f an init) ...)). Not tail-recursive.
iter2 ~f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
map2 ~f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].
fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn] is f (... (f (f init a1 b1) a2 b2) ...) an bn.
fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init is f a1 b1 (f a2 b2 (... (f an bn init) ...)).
for_all ~f [a1; ...; an] checks if all elements of the list satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an) for a non-empty list and true if the list is empty.
exists ~f [a1; ...; an] checks if at least one element of the list satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an) for a non-empty list and false if the list is empty.
Same as for_all, but for a two-argument predicate.
Same as exists, but for a two-argument predicate.
mem a ~set is true if and only if a is equal to an element of set.
Same as mem, but uses physical equality instead of structural equality to compare list elements.
find ~f l returns the first element of the list l that satisfies the predicate f.
find ~f l returns the first element of the list l that satisfies the predicate f. Returns None if there is no value that satisfies f in the list l.
find_map ~f l applies f to the elements of l in order, and returns the first result of the form Some v, or None if none exist.
filter ~f l returns all the elements of the list l that satisfy the predicate f. The order of the elements in the input list is preserved.
find_all is another name for filter.
Same as filter, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
partition ~f l returns a pair of lists (l1, l2), where l1 is the list of all the elements of l that satisfy the predicate f, and l2 is the list of all the elements of l that do not satisfy f. The order of the elements in the input list is preserved.
val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c listpartition_map f l returns a pair of lists (l1, l2) such that, for each element x of the input list l:
f x is Left y1, then y1 is in l1, andf x is Right y2, then y2 is in l2.The output elements are included in l1 and l2 in the same relative order as the corresponding input elements in l.
In particular, partition_map (fun x -> if f x then Left x else Right x) l is equivalent to partition f l.
assoc a l returns the value associated with key a in the list of pairs l. That is, assoc a [ ...; (a,b); ...] = b if (a,b) is the leftmost binding of a in list l.
assoc_opt a l returns the value associated with key a in the list of pairs l. That is, assoc_opt a [ ...; (a,b); ...] = Some b if (a,b) is the leftmost binding of a in list l. Returns None if there is no value associated with a in the list l.
Same as assoc, but uses physical equality instead of structural equality to compare keys.
Same as assoc_opt, but uses physical equality instead of structural equality to compare keys.
Same as assoc, but simply return true if a binding exists, and false if no bindings exist for the given key.
Same as mem_assoc, but uses physical equality instead of structural equality to compare keys.
remove_assoc a l returns the list of pairs l without the first pair with key a, if any. Not tail-recursive.
Same as remove_assoc, but uses physical equality instead of structural equality to compare keys. Not tail-recursive.
Transform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]). Not tail-recursive.
Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
Sort a list in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see Array.sort for a complete specification). For example, Stdlib.compare is a suitable comparison function. The resulting list is sorted in increasing order. sort is guaranteed to run in constant heap space (in addition to the size of the result list) and logarithmic stack space.
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
Same as sort, but the sorting algorithm is guaranteed to be stable (i.e. elements that compare equal are kept in their original order).
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
Same as sort or stable_sort, whichever is faster on typical input.
Same as sort, but also remove duplicates.
Merge two lists: Assuming that l1 and l2 are sorted according to the comparison function cmp, merge ~cmp l1 l2 will return a sorted list containing all the elements of l1 and l2. If several elements compare equal, the elements of l1 will be before the elements of l2. Not tail-recursive (sum of the lengths of the arguments).
val to_seq : 'a list -> 'a Seq.tIterate on the list.
val of_seq : 'a Seq.t -> 'a listCreate a list from a sequence.
Make.OrdA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Map.MakeFunctor building an implementation of the map structure given a totally ordered type.
module Ord : OrderedTypetype key = Ord.tThe type of the map keys.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Stdlib.MapAssociation tables over ordered types.
This module implements applicative association tables, also known as finite maps or dictionaries, given a total ordering function over the keys. All operations over maps are purely applicative (no side-effects). The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
For instance:
module IntPairs =
+ struct
+ type t = int * int
+ let compare (x0,y0) (x1,y1) =
+ match Stdlib.compare x0 x1 with
+ 0 -> Stdlib.compare y0 y1
+ | c -> c
+ end
+
+module PairsMap = Map.Make(IntPairs)
+
+let m = PairsMap.(empty |> add (0,1) "hello" |> add (1,0) "world")This creates a new module PairsMap, with a new type 'a PairsMap.t of maps from int * int to 'a. In this example, m contains string values so its type is string PairsMap.t.
module type OrderedType = sig ... endInput signature of the functor Make.
Map.OrderedTypeInput signature of the functor Make.
A total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Map.SOutput signature of the functor Make.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Stdlib.MarshalMarshaling of data structures.
This module provides functions to encode arbitrary data structures as sequences of bytes, which can then be written on a file or sent over a pipe or network connection. The bytes can then be read back later, possibly in another process, and decoded back into a data structure. The format for the byte sequences is compatible across all machines for a given version of OCaml.
Warning: marshaling is currently not type-safe. The type of marshaled data is not transmitted along the value of the data, making it impossible to check that the data read back possesses the type expected by the context. In particular, the result type of the Marshal.from_* functions is given as 'a, but this is misleading: the returned OCaml value does not possess type 'a for all 'a; it has one, unique type which cannot be determined at compile-time. The programmer should explicitly give the expected type of the returned value, using the following syntax:
(Marshal.from_channel chan : type). Anything can happen at run-time if the object in the file does not belong to the given type.Values of extensible variant types, for example exceptions (of extensible type exn), returned by the unmarshaller should not be pattern-matched over through match ... with or try ... with, because unmarshalling does not preserve the information required for matching their constructors. Structural equalities with other extensible variant values does not work either. Most other uses such as Printexc.to_string, will still work as expected.
The representation of marshaled values is not human-readable, and uses bytes that are not printable characters. Therefore, input and output channels used in conjunction with Marshal.to_channel and Marshal.from_channel must be opened in binary mode, using e.g. open_out_bin or open_in_bin; channels opened in text mode will cause unmarshaling errors on platforms where text channels behave differently than binary channels, e.g. Windows.
val to_channel : out_channel -> 'a -> extern_flags list -> unitMarshal.to_channel chan v flags writes the representation of v on channel chan. The flags argument is a possibly empty list of flags that governs the marshaling behavior with respect to sharing, functional values, and compatibility between 32- and 64-bit platforms.
If flags does not contain Marshal.No_sharing, circularities and sharing inside the value v are detected and preserved in the sequence of bytes produced. In particular, this guarantees that marshaling always terminates. Sharing between values marshaled by successive calls to Marshal.to_channel is neither detected nor preserved, though. If flags contains Marshal.No_sharing, sharing is ignored. This results in faster marshaling if v contains no shared substructures, but may cause slower marshaling and larger byte representations if v actually contains sharing, or even non-termination if v contains cycles.
If flags does not contain Marshal.Closures, marshaling fails when it encounters a functional value inside v: only 'pure' data structures, containing neither functions nor objects, can safely be transmitted between different programs. If flags contains Marshal.Closures, functional values will be marshaled as a the position in the code of the program together with the values corresponding to the free variables captured in the closure. In this case, the output of marshaling can only be read back in processes that run exactly the same program, with exactly the same compiled code. (This is checked at un-marshaling time, using an MD5 digest of the code transmitted along with the code position.)
The exact definition of which free variables are captured in a closure is not specified and can vary between bytecode and native code (and according to optimization flags). In particular, a function value accessing a global reference may or may not include the reference in its closure. If it does, unmarshaling the corresponding closure will create a new reference, different from the global one.
If flags contains Marshal.Compat_32, marshaling fails when it encounters an integer value outside the range [-2{^30}, 2{^30}-1] of integers that are representable on a 32-bit platform. This ensures that marshaled data generated on a 64-bit platform can be safely read back on a 32-bit platform. If flags does not contain Marshal.Compat_32, integer values outside the range [-2{^30}, 2{^30}-1] are marshaled, and can be read back on a 64-bit platform, but will cause an error at un-marshaling time when read back on a 32-bit platform. The Mashal.Compat_32 flag only matters when marshaling is performed on a 64-bit platform; it has no effect if marshaling is performed on a 32-bit platform.
val to_bytes : 'a -> extern_flags list -> bytesMarshal.to_bytes v flags returns a byte sequence containing the representation of v. The flags argument has the same meaning as for Marshal.to_channel.
val to_string : 'a -> extern_flags list -> stringSame as to_bytes but return the result as a string instead of a byte sequence.
val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> intMarshal.to_buffer buff ofs len v flags marshals the value v, storing its byte representation in the sequence buff, starting at index ofs, and writing at most len bytes. It returns the number of bytes actually written to the sequence. If the byte representation of v does not fit in len characters, the exception Failure is raised.
val from_channel : in_channel -> 'aMarshal.from_channel chan reads from channel chan the byte representation of a structured value, as produced by one of the Marshal.to_* functions, and reconstructs and returns the corresponding value.
Marshal.from_bytes buff ofs unmarshals a structured value like Marshal.from_channel does, except that the byte representation is not read from a channel, but taken from the byte sequence buff, starting at position ofs. The byte sequence is not mutated.
Same as from_bytes but take a string as argument instead of a byte sequence.
The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header. Marshal.header_size is the size, in bytes, of the header. Marshal.data_size buff ofs is the size, in bytes, of the data part, assuming a valid header is stored in buff starting at position ofs. Finally, Marshal.total_size buff ofs is the total size, in bytes, of the marshaled value. Both Marshal.data_size and Marshal.total_size raise Failure if buff, ofs does not contain a valid header.
To read the byte representation of a marshaled value into a byte sequence, the program needs to read first Marshal.header_size bytes into the sequence, then determine the length of the remainder of the representation using Marshal.data_size, make sure the sequence is large enough to hold the remaining data, then read it, and finally call Marshal.from_bytes to unmarshal the value.
See Marshal.header_size.
See Marshal.header_size.
Make.Hval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Hashtbl.MakeFunctor building an implementation of the hashtable structure. The functor Hashtbl.Make returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the hashing and equality functions specified in the functor argument H instead of generic equality and hashing. Since the hash function is not seeded, the create operation of the result structure always returns non-randomized hash tables.
module H : HashedTypetype key = H.ttype 'a t = 'a Hashtbl.Make(H).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsMakeSeeded.Hval hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
Hashtbl.MakeSeededFunctor building an implementation of the hashtable structure. The functor Hashtbl.MakeSeeded returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the seeded hashing and equality functions specified in the functor argument H instead of generic equality and hashing. The create operation of the result structure supports the ~random optional parameter and returns randomized hash tables if ~random:true is passed or if randomization is globally on (see Hashtbl.randomize).
module H : SeededHashedTypetype key = H.ttype 'a t = 'a Hashtbl.MakeSeeded(H).tval create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsMoreLabels.HashtblHash tables and hash functions.
Hash tables are hashed association tables, with in-place modification.
type (!'a, !'b) t = ('a, 'b) Hashtbl.tThe type of hash tables from type 'a to type 'b.
val create : ?random:bool -> int -> ('a, 'b) tHashtbl.create n creates a new, empty hash table, with initial size n. For best results, n should be on the order of the expected number of elements that will be in the table. The table grows as needed, so n is just an initial guess.
The optional ~random parameter (a boolean) controls whether the internal organization of the hash table is randomized at each execution of Hashtbl.create or deterministic over all executions.
A hash table that is created with ~random set to false uses a fixed hash function (hash) to distribute keys among buckets. As a consequence, collisions between keys happen deterministically. In Web-facing applications or other security-sensitive applications, the deterministic collision patterns can be exploited by a malicious user to create a denial-of-service attack: the attacker sends input crafted to create many collisions in the table, slowing the application down.
A hash table that is created with ~random set to true uses the seeded hash function seeded_hash with a seed that is randomly chosen at hash table creation time. In effect, the hash function used is randomly selected among 2^{30} different hash functions. All these hash functions have different collision patterns, rendering ineffective the denial-of-service attack described above. However, because of randomization, enumerating all elements of the hash table using fold or iter is no longer deterministic: elements are enumerated in different orders at different runs of the program.
If no ~random parameter is given, hash tables are created in non-random mode by default. This default can be changed either programmatically by calling randomize or by setting the R flag in the OCAMLRUNPARAM environment variable.
val clear : ('a, 'b) t -> unitEmpty a hash table. Use reset instead of clear to shrink the size of the bucket table to its initial size.
val reset : ('a, 'b) t -> unitEmpty a hash table and shrink the size of the bucket table to its initial size.
val add : ('a, 'b) t -> key:'a -> data:'b -> unitHashtbl.add tbl ~key ~data adds a binding of key to data in table tbl. Previous bindings for key are not removed, but simply hidden. That is, after performing remove tbl key, the previous binding for key, if any, is restored. (Same behavior as with association lists.)
val find : ('a, 'b) t -> 'a -> 'bHashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
val find_opt : ('a, 'b) t -> 'a -> 'b optionHashtbl.find_opt tbl x returns the current binding of x in tbl, or None if no such binding exists.
val find_all : ('a, 'b) t -> 'a -> 'b listHashtbl.find_all tbl x returns the list of all data associated with x in tbl. The current binding is returned first, then the previous bindings, in reverse order of introduction in the table.
val mem : ('a, 'b) t -> 'a -> boolHashtbl.mem tbl x checks if x is bound in tbl.
val remove : ('a, 'b) t -> 'a -> unitHashtbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists. It does nothing if x is not bound in tbl.
val replace : ('a, 'b) t -> key:'a -> data:'b -> unitval iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unitHashtbl.iter ~f tbl applies f to all bindings in table tbl. f receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to f.
The order in which the bindings are passed to f is unspecified. However, if the table contains several bindings for the same key, they are passed to f in reverse order of introduction, that is, the most recent binding is passed first.
If the hash table was created in non-randomized mode, the order in which the bindings are enumerated is reproducible between successive runs of the program, and even between minor versions of OCaml. For randomized hash tables, the order of enumeration is entirely random.
The behavior is not specified if the hash table is modified by f during the iteration.
val filter_map_inplace :
+ f:(key:'a -> data:'b -> 'b option) ->
+ ('a, 'b) t ->
+ unitHashtbl.filter_map_inplace ~f tbl applies f to all bindings in table tbl and update each binding depending on the result of f. If f returns None, the binding is discarded. If it returns Some new_val, the binding is update to associate the key to new_val.
Other comments for iter apply as well.
val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'cHashtbl.fold ~f tbl ~init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values. Each binding is presented exactly once to f.
The order in which the bindings are passed to f is unspecified. However, if the table contains several bindings for the same key, they are passed to f in reverse order of introduction, that is, the most recent binding is passed first.
If the hash table was created in non-randomized mode, the order in which the bindings are enumerated is reproducible between successive runs of the program, and even between minor versions of OCaml. For randomized hash tables, the order of enumeration is entirely random.
The behavior is not specified if the hash table is modified by f during the iteration.
val length : ('a, 'b) t -> intHashtbl.length tbl returns the number of bindings in tbl. It takes constant time. Multiple bindings are counted once each, so Hashtbl.length gives the number of times Hashtbl.iter calls its first argument.
After a call to Hashtbl.randomize(), hash tables are created in randomized mode by default: create returns randomized hash tables, unless the ~random:false optional parameter is given. The same effect can be achieved by setting the R parameter in the OCAMLRUNPARAM environment variable.
It is recommended that applications or Web frameworks that need to protect themselves against the denial-of-service attack described in create call Hashtbl.randomize() at initialization time.
Note that once Hashtbl.randomize() was called, there is no way to revert to the non-randomized default behavior of create. This is intentional. Non-randomized hash tables can still be created using Hashtbl.create ~random:false.
Return true if the tables are currently created in randomized mode by default, false otherwise.
Return a copy of the given hashtable. Unlike copy, rebuild h re-hashes all the (key, value) entries of the original table h. The returned hash table is randomized if h was randomized, or the optional random parameter is true, or if the default is to create randomized hash tables; see create for more information.
rebuild can safely be used to import a hash table built by an old version of the Hashtbl module, then marshaled to persistent storage. After unmarshaling, apply rebuild to produce a hash table for the current version of the Hashtbl module.
type statistics = Hashtbl.statistics = {num_bindings : int;num_buckets : int;Number of buckets in the table.
*)max_bucket_length : int;Maximal number of bindings per bucket.
*)bucket_histogram : int array;Histogram of bucket sizes. This array histo has length max_bucket_length + 1. The value of histo.(i) is the number of buckets whose size is i.
}val stats : ('a, 'b) t -> statisticsHashtbl.stats tbl returns statistics about the table tbl: number of buckets, size of the biggest bucket, distribution of buckets by size.
Iterate on the whole table. The order in which the bindings appear in the sequence is unspecified. However, if the table contains several bindings for the same key, they appear in reversed order of introduction, that is, the most recent binding appears first.
The behavior is not specified if the hash table is modified during the iteration.
Add the given bindings to the table, using replace
Build a table from the given bindings. The bindings are added in the same order they appear in the sequence, using replace_seq, which means that if two pairs have the same key, only the latest one will appear in the table.
The functorial interface allows the use of specific comparison and hash functions, either for performance/security concerns, or because keys are not hashable/comparable with the polymorphic builtins.
For instance, one might want to specialize a table for integer keys:
module IntHash =
+ struct
+ type t = int
+ let equal i j = i=j
+ let hash i = i land max_int
+ end
+
+module IntHashtbl = Hashtbl.Make(IntHash)
+
+let h = IntHashtbl.create 17 in
+IntHashtbl.add h 12 "hello"This creates a new module IntHashtbl, with a new type 'a
+ IntHashtbl.t of tables from int to 'a. In this example, h contains string values so its type is string IntHashtbl.t.
Note that the new type 'a IntHashtbl.t is not compatible with the type ('a,'b) Hashtbl.t of the generic interface. For example, Hashtbl.length h would not type-check, you must use IntHashtbl.length.
module type HashedType = sig ... endThe input signature of the functor Make.
module Make
+ (H : HashedType) :
+ S with type key = H.t and type 'a t = 'a Hashtbl.Make(H).tFunctor building an implementation of the hashtable structure. The functor Hashtbl.Make returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the hashing and equality functions specified in the functor argument H instead of generic equality and hashing. Since the hash function is not seeded, the create operation of the result structure always returns non-randomized hash tables.
module type SeededHashedType = sig ... endThe input signature of the functor MakeSeeded.
module type SeededS = sig ... endThe output signature of the functor MakeSeeded.
module MakeSeeded
+ (H : SeededHashedType) :
+ SeededS with type key = H.t and type 'a t = 'a Hashtbl.MakeSeeded(H).tFunctor building an implementation of the hashtable structure. The functor Hashtbl.MakeSeeded returns a structure containing a type key of keys and a type 'a t of hash tables associating data of type 'a to keys of type key. The operations perform similarly to those of the generic interface, but use the seeded hashing and equality functions specified in the functor argument H instead of generic equality and hashing. The create operation of the result structure supports the ~random optional parameter and returns randomized hash tables if ~random:true is passed or if randomization is globally on (see Hashtbl.randomize).
Hashtbl.hash x associates a nonnegative integer to any value of any type. It is guaranteed that if x = y or Stdlib.compare x y = 0, then hash x = hash y. Moreover, hash always terminates, even on cyclic structures.
A variant of hash that is further parameterized by an integer seed.
Hashtbl.hash_param meaningful total x computes a hash value for x, with the same properties as for hash. The two extra integer parameters meaningful and total give more precise control over hashing. Hashing performs a breadth-first, left-to-right traversal of the structure x, stopping after meaningful meaningful nodes were encountered, or total nodes (meaningful or not) were encountered. If total as specified by the user exceeds a certain value, currently 256, then it is capped to that value. Meaningful nodes are: integers; floating-point numbers; strings; characters; booleans; and constant constructors. Larger values of meaningful and total means that more nodes are taken into account to compute the final hash value, and therefore collisions are less likely to happen. However, hashing takes longer. The parameters meaningful and total govern the tradeoff between accuracy and speed. As default choices, hash and seeded_hash take meaningful = 10 and total = 100.
A variant of hash_param that is further parameterized by an integer seed. Usage: Hashtbl.seeded_hash_param meaningful total seed x.
Hashtbl.HashedTypeThe input signature of the functor Make.
val hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Hashtbl.SThe output signature of the functor Make.
val create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsHashtbl.SeededHashedTypeThe input signature of the functor MakeSeeded.
val hash : int -> t -> intA seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then hash seed x = hash seed y for any value of seed. A suitable choice for hash is the function Stdlib.Hashtbl.seeded_hash below.
Hashtbl.SeededSThe output signature of the functor MakeSeeded.
val create : ?random:bool -> int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> statisticsMake.OrdA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Map.MakeFunctor building an implementation of the map structure given a totally ordered type.
module Ord : OrderedTypetype key = Ord.tThe type of the map keys.
type 'a t = 'a Map.Make(Ord).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update ~key ~f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal ~cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter ~f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold ~f m ~init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all ~f m checks if all the bindings of the map satisfy the predicate f.
exists ~f m checks if at least one binding of the map satisfies the predicate f.
filter ~f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map ~f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition ~f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first ~f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt ~f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last ~f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt ~f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map ~f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
MoreLabels.MapAssociation tables over ordered types.
This module implements applicative association tables, also known as finite maps or dictionaries, given a total ordering function over the keys. All operations over maps are purely applicative (no side-effects). The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
For instance:
module IntPairs =
+ struct
+ type t = int * int
+ let compare (x0,y0) (x1,y1) =
+ match Stdlib.compare x0 x1 with
+ 0 -> Stdlib.compare y0 y1
+ | c -> c
+ end
+
+module PairsMap = Map.Make(IntPairs)
+
+let m = PairsMap.(empty |> add (0,1) "hello" |> add (1,0) "world")This creates a new module PairsMap, with a new type 'a PairsMap.t of maps from int * int to 'a. In this example, m contains string values so its type is string PairsMap.t.
module type OrderedType = sig ... endInput signature of the functor Make.
module Make
+ (Ord : OrderedType) :
+ S with type key = Ord.t and type 'a t = 'a Map.Make(Ord).tFunctor building an implementation of the map structure given a totally ordered type.
Map.OrderedTypeInput signature of the functor Make.
A total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Map.SOutput signature of the functor Make.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update ~key ~f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal ~cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter ~f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold ~f m ~init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all ~f m checks if all the bindings of the map satisfy the predicate f.
exists ~f m checks if at least one binding of the map satisfies the predicate f.
filter ~f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map ~f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition ~f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first ~f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt ~f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last ~f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt ~f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map ~f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Make.OrdA total ordering function over the set elements. This is a two-argument function f such that f e1 e2 is zero if the elements e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Set.MakeFunctor building an implementation of the set structure given a totally ordered type.
module Ord : OrderedTypetype elt = Ord.tThe type of the set elements.
type t = Set.Make(Ord).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter ~f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map ~f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold ~f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all ~f s checks if all elements of the set satisfy the predicate f.
exists ~f s checks if at least one element of the set satisfies the predicate f.
filter ~f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map ~f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition ~f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first ~f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt ~f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last ~f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt ~f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
MoreLabels.SetSets over ordered types.
This module implements the set data structure, given a total ordering function over the set elements. All operations over sets are purely applicative (no side-effects). The implementation uses balanced binary trees, and is therefore reasonably efficient: insertion and membership take time logarithmic in the size of the set, for instance.
The Make functor constructs implementations for any type, given a compare function. For instance:
module IntPairs =
+ struct
+ type t = int * int
+ let compare (x0,y0) (x1,y1) =
+ match Stdlib.compare x0 x1 with
+ 0 -> Stdlib.compare y0 y1
+ | c -> c
+ end
+
+module PairsSet = Set.Make(IntPairs)
+
+let m = PairsSet.(empty |> add (2,3) |> add (5,7) |> add (11,13))This creates a new module PairsSet, with a new type PairsSet.t of sets of int * int.
module type OrderedType = sig ... endInput signature of the functor Make.
module Make
+ (Ord : OrderedType) :
+ S with type elt = Ord.t and type t = Set.Make(Ord).tFunctor building an implementation of the set structure given a totally ordered type.
Set.OrderedTypeInput signature of the functor Make.
A total ordering function over the set elements. This is a two-argument function f such that f e1 e2 is zero if the elements e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Set.SOutput signature of the functor Make.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter ~f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map ~f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold ~f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all ~f s checks if all elements of the set satisfy the predicate f.
exists ~f s checks if at least one element of the set satisfies the predicate f.
filter ~f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map ~f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition ~f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first ~f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt ~f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last ~f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt ~f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Stdlib.MoreLabelsExtra labeled libraries.
This meta-module provides labelized versions of the Hashtbl, Map and Set modules.
This module is intended to be used through open MoreLabels which replaces Hashtbl, Map, and Set with their labeled counterparts.
For example:
open MoreLabels
+
+Hashtbl.iter ~f:(fun ~key ~data -> g key data) tablemodule Hashtbl : sig ... endHash tables and hash functions.
module Map : sig ... endAssociation tables over ordered types.
module Set : sig ... endSets over ordered types.
Stdlib.NativeintProcessor-native integers.
This module provides operations on the type nativeint of signed 32-bit integers (on 32-bit platforms) or signed 64-bit integers (on 64-bit platforms). This integer type has exactly the same width as that of a pointer type in the C compiler. All arithmetic operations over nativeint are taken modulo 232 or 264 depending on the word size of the architecture.
Performance notice: values of type nativeint occupy more memory space than values of type int, and arithmetic operations on nativeint are generally slower than those on int. Use nativeint only when the application requires the extra bit of precision over the int type.
Literals for native integers are suffixed by n:
let zero: nativeint = 0n
+let one: nativeint = 1n
+let m_one: nativeint = -1nInteger division. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/).
Same as div, except that arguments and result are interpreted as unsigned native integers.
Integer remainder. If y is not zero, the result of Nativeint.rem x y satisfies the following properties: Nativeint.zero <= Nativeint.rem x y < Nativeint.abs y and x = Nativeint.add (Nativeint.mul (Nativeint.div x y) y)
+ (Nativeint.rem x y). If y = 0, Nativeint.rem x y raises Division_by_zero.
Same as rem, except that arguments and result are interpreted as unsigned native integers.
The size in bits of a native integer. This is equal to 32 on a 32-bit platform and to 64 on a 64-bit platform.
The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
Nativeint.shift_left x y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= bitsize, where bitsize is 32 on a 32-bit platform and 64 on a 64-bit platform.
Nativeint.shift_right x y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= bitsize.
Nativeint.shift_right_logical x y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= bitsize.
Convert the given integer (type int) to a native integer (type nativeint).
Convert the given native integer (type nativeint) to an integer (type int). The high-order bit is lost during the conversion.
Same as to_int, but interprets the argument as an unsigned integer. Returns None if the unsigned value of the argument cannot fit into an int.
Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0). If the truncated floating-point number is outside the range [Nativeint.min_int, Nativeint.max_int], no exception is raised, and an unspecified, platform-dependent integer is returned.
Convert the given native integer to a 32-bit integer (type int32). On 64-bit platforms, the 64-bit native integer is taken modulo 232, i.e. the top 32 bits are lost. On 32-bit platforms, the conversion is exact.
Convert the given string to a native integer. The string is read in decimal (by default, or if the string begins with 0u) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively.
The 0u prefix reads the input as an unsigned integer in the range [0, 2*Nativeint.max_int+1]. If the input exceeds Nativeint.max_int it is converted to the signed integer Int64.min_int + input - Nativeint.max_int - 1.
Same as of_string, but return None instead of raising.
The comparison function for native integers, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Nativeint to be passed as argument to the functors Set.Make and Map.Make.
Same as compare, except that arguments are interpreted as unsigned native integers.
Obj.ClosureObj.EphemeronEphemeron with arbitrary arity and untyped
an ephemeron cf Ephemeron
val create : int -> tcreate n returns an ephemeron with n keys. All the keys and the data are initially empty. The argument n must be between zero and max_ephe_length (limits included).
val length : t -> intreturn the number of keys
Same as Stdlib.Ephemeron.K1.get_key
Same as Stdlib.Ephemeron.K1.get_key_copy
Same as Stdlib.Ephemeron.K1.set_key
val unset_key : t -> int -> unitSame as Stdlib.Ephemeron.K1.unset_key
val check_key : t -> int -> boolSame as Stdlib.Ephemeron.K1.check_key
Same as Stdlib.Ephemeron.K1.blit_key
Same as Stdlib.Ephemeron.K1.get_data
Same as Stdlib.Ephemeron.K1.set_data
val unset_data : t -> unitSame as Stdlib.Ephemeron.K1.unset_data
val check_data : t -> boolSame as Stdlib.Ephemeron.K1.check_data
Same as Stdlib.Ephemeron.K1.blit_data
Obj.Extension_constructorStdlib.ObjOperations on internal representations of values.
Not for the casual user.
val repr : 'a -> tval obj : t -> 'aval is_block : t -> boolval is_int : t -> boolval tag : t -> intval size : t -> intval reachable_words : t -> intComputes the total size (in words, including the headers) of all heap blocks accessible from the argument. Statically allocated blocks are excluded, unless the runtime system was configured with --disable-naked-pointers.
When using flambda:
set_field MUST NOT be called on immutable blocks. (Blocks allocated in C stubs, or with new_block below, are always considered mutable.)
The same goes for set_double_field and set_tag. However, for set_tag, in the case of immutable blocks where the middle-end optimizers never see code that discriminates on their tag (for example records), the operation should be safe. Such uses are nonetheless discouraged.
For experts only: set_field et al can be made safe by first wrapping the block in Sys.opaque_identity, so any information about its contents will not be propagated.
val set_tag : t -> int -> unitval double_field : t -> int -> floatval set_double_field : t -> int -> float -> unitval new_block : int -> int -> tval truncate : t -> int -> unitmodule Closure : sig ... endmodule Extension_constructor : sig ... endmodule Ephemeron : sig ... endEphemeron with arbitrary arity and untyped
Stdlib.OoOperations on objects
Oo.copy o returns a copy of object o, that is a fresh object with the same methods and instance variables as o.
Return an integer identifying this object, unique for the current execution of the program. The generic comparison and hashing functions are based on this integer. When an object is obtained by unmarshaling, the id is refreshed, and thus different from the original object. As a consequence, the internal invariants of data structures such as hash table or sets containing objects are broken after unmarshaling the data structures.
Stdlib.OptionOption values.
Option values explicitly indicate the presence or absence of a value.
The type for option values. Either None or a value Some v.
value o ~default is v if o is Some v and default otherwise.
bind o f is f v if o is Some v and None if o is None.
join oo is Some v if oo is Some (Some v) and None otherwise.
map f o is None if o is None and Some (f v) is o is Some v.
fold ~none ~some o is none if o is None and some v if o is Some v.
equal eq o0 o1 is true if and only if o0 and o1 are both None or if they are Some v0 and Some v1 and eq v0 v1 is true.
compare cmp o0 o1 is a total order on options using cmp to compare values wrapped by Some _. None is smaller than Some _ values.
val to_result : none:'e -> 'a option -> ('a, 'e) resultto_result ~none o is Ok v if o is Some v and Error none otherwise.
val to_seq : 'a option -> 'a Seq.tto_seq o is o as a sequence. None is the empty sequence and Some v is the singleton sequence containing v.
Stdlib.Out_channelOutput channels.
type t = out_channelThe type of output channel.
type open_flag = open_flag = | Open_rdonlyopen for reading.
*)| Open_wronlyopen for writing.
*)| Open_appendopen for appending: always write at end of file.
*)| Open_creatcreate the file if it does not exist.
*)| Open_truncempty the file if it already exists.
*)| Open_exclfail if Open_creat and the file already exists.
*)| Open_binaryopen in binary mode (no conversion).
*)| Open_textopen in text mode (may perform conversions).
*)| Open_nonblockopen in non-blocking mode.
*)Opening modes for open_gen.
val stdout : tThe standard output for the process.
val stderr : tThe standard error output for the process.
val open_bin : string -> tOpen the named file for writing, and return a new output channel on that file, positioned at the beginning of the file. The file is truncated to zero length if it already exists. It is created if it does not already exists.
val open_text : string -> tval with_open_bin : string -> (t -> 'a) -> 'awith_open_bin fn f opens a channel oc on file fn and returns f
+ oc. After f returns, either with a value or by raising an exception, oc is guaranteed to be closed.
val with_open_text : string -> (t -> 'a) -> 'aLike with_open_bin, but the channel is opened in text mode (see open_text).
Like with_open_bin, but can specify the opening mode and file permission, in case the file must be created (see open_gen).
val seek : t -> int64 -> unitseek chan pos sets the current writing position to pos for channel chan. This works only for regular files. On files of other kinds (such as terminals, pipes and sockets), the behavior is unspecified.
val pos : t -> int64Return the current writing position for the given channel. Does not work on channels opened with the Open_append flag (returns unspecified results).
For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos, then going back to this position using seek will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
val length : t -> int64Return the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless.
val close : t -> unitClose the given channel, flushing all buffered write operations. Output functions raise a Sys_error exception when they are applied to a closed output channel, except close and flush, which do nothing when applied to an already closed channel. Note that close may raise Sys_error if the operating system signals an error when flushing or closing.
val flush : t -> unitFlush the buffer associated with the given output channel, performing all pending writes on that channel. Interactive programs must be careful about flushing standard output and standard error at the right time.
val output_char : t -> char -> unitWrite the character on the given output channel.
val output_byte : t -> int -> unitWrite one 8-bit integer (as the single character with that code) on the given output channel. The given integer is taken modulo 256.
val output_string : t -> string -> unitWrite the string on the given output channel.
val output_bytes : t -> bytes -> unitWrite the byte sequence on the given output channel.
val output : t -> bytes -> int -> int -> unitoutput oc buf pos len writes len characters from byte sequence buf, starting at offset pos, to the given output channel oc.
val output_substring : t -> string -> int -> int -> unitSame as output but take a string as argument instead of a byte sequence.
val set_binary_mode : t -> bool -> unitset_binary_mode oc true sets the channel oc to binary mode: no translations take place during output.
set_binary_mode oc false sets the channel oc to text mode: depending on the operating system, some translations may take place during output. For instance, under Windows, end-of-lines will be translated from \n to \r\n.
This function has no effect under operating systems that do not distinguish between text mode and binary mode.
val set_buffered : t -> bool -> unitset_buffered oc true sets the channel oc to buffered mode. In this mode, data output on oc will be buffered until either the internal buffer is full or the function flush or flush_all is called, at which point it will be sent to the output device.
set_buffered oc false sets the channel oc to unbuffered mode. In this mode, data output on oc will be sent to the output device immediately.
All channels are open in buffered mode by default.
val is_buffered : t -> boolis_buffered oc returns whether the channel oc is buffered (see set_buffered).
Stdlib.ParsingThe run-time library for parsers generated by ocamlyacc.
symbol_start and Parsing.symbol_end are to be called in the action part of a grammar rule only. They return the offset of the string that matches the left-hand side of the rule: symbol_start() returns the offset of the first character; symbol_end() returns the offset after the last character. The first character in a file is at offset 0.
See Parsing.symbol_start.
Same as Parsing.symbol_start and Parsing.symbol_end, but return the offset of the string matching the nth item on the right-hand side of the rule, where n is the integer parameter to rhs_start and rhs_end. n is 1 for the leftmost item.
See Parsing.rhs_start.
val symbol_start_pos : unit -> Lexing.positionSame as symbol_start, but return a position instead of an offset.
val symbol_end_pos : unit -> Lexing.positionSame as symbol_end, but return a position instead of an offset.
val rhs_start_pos : int -> Lexing.positionSame as rhs_start, but return a position instead of an offset.
val rhs_end_pos : int -> Lexing.positionSame as rhs_end, but return a position instead of an offset.
Empty the parser stack. Call it just after a parsing function has returned, to remove all pointers from the parser stack to structures that were built by semantic actions during parsing. This is optional, but lowers the memory requirements of the programs.
Raised when a parser encounters a syntax error. Can also be raised from the action part of a grammar rule, to initiate error recovery.
Control debugging support for ocamlyacc-generated parsers. After Parsing.set_trace true, the pushdown automaton that executes the parsers prints a trace of its actions (reading a token, shifting a state, reducing by a rule) on standard output. Parsing.set_trace false turns this debugging trace off. The boolean returned is the previous state of the trace flag.
Stdlib.Pervasivesval classify_float : float -> fpclasstype nonrec in_channel = in_channeltype nonrec out_channel = out_channelval stdin : in_channelval stdout : out_channelval stderr : out_channeltype nonrec open_flag = open_flag = val open_out : string -> out_channelval open_out_bin : string -> out_channelval open_out_gen : open_flag list -> int -> string -> out_channelval flush : out_channel -> unitval output_char : out_channel -> char -> unitval output_string : out_channel -> string -> unitval output_bytes : out_channel -> bytes -> unitval output : out_channel -> bytes -> int -> int -> unitval output_substring : out_channel -> string -> int -> int -> unitval output_byte : out_channel -> int -> unitval output_binary_int : out_channel -> int -> unitval output_value : out_channel -> 'a -> unitval seek_out : out_channel -> int -> unitval pos_out : out_channel -> intval out_channel_length : out_channel -> intval close_out : out_channel -> unitval close_out_noerr : out_channel -> unitval set_binary_mode_out : out_channel -> bool -> unitval open_in : string -> in_channelval open_in_bin : string -> in_channelval open_in_gen : open_flag list -> int -> string -> in_channelval input_char : in_channel -> charval input_line : in_channel -> stringval input : in_channel -> bytes -> int -> int -> intval really_input : in_channel -> bytes -> int -> int -> unitval really_input_string : in_channel -> int -> stringval input_byte : in_channel -> intval input_binary_int : in_channel -> intval input_value : in_channel -> 'aval seek_in : in_channel -> int -> unitval pos_in : in_channel -> intval in_channel_length : in_channel -> intval close_in : in_channel -> unitval close_in_noerr : in_channel -> unitval set_binary_mode_in : in_channel -> bool -> unitmodule LargeFile = LargeFileval ref : 'a -> 'a refval (!) : 'a ref -> 'aval (:=) : 'a ref -> 'a -> unitval incr : int ref -> unitval decr : int ref -> unittype ('a, 'b, 'c, 'd, 'e, 'f) format6 =
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> stringPrintexc.Slottype t = backtrace_slotval is_raise : t -> boolis_raise slot is true when slot refers to a raising point in the code, and false when it comes from a simple function call.
val is_inline : t -> boolis_inline slot is true when slot refers to a call that got inlined by the compiler, and false when it comes from any other context.
location slot returns the location information of the slot, if available, and None otherwise.
Some possible reasons for failing to return a location are as follow:
-g)val name : t -> string optionname slot returns the name of the function or definition enclosing the location referred to by the slot.
name slot returns None if the name is unavailable, which may happen for the same reasons as location returning None.
val format : int -> t -> string optionformat pos slot returns the string representation of slot as raw_backtrace_to_string would format it, assuming it is the pos-th element of the backtrace: the 0-th element is pretty-printed differently than the others.
Whole-backtrace printing functions also skip some uninformative slots; in that case, format pos slot returns None.
Stdlib.PrintexcFacilities for printing exceptions and inspecting current call stack.
Printexc.to_string e returns a string representation of the exception e.
Printexc.to_string_default e returns a string representation of the exception e, ignoring all registered exception printers.
Printexc.print fn x applies fn to x and returns the result. If the evaluation of fn x raises any exception, the name of the exception is printed on standard error output, and the exception is raised again. The typical use is to catch and report exceptions that escape a function application.
Printexc.catch fn x is similar to Printexc.print, but aborts the program with exit code 2 after printing the uncaught exception. This function is deprecated: the runtime system is now able to print uncaught exceptions as precisely as Printexc.catch does. Moreover, calling Printexc.catch makes it harder to track the location of the exception using the debugger or the stack backtrace facility. So, do not use Printexc.catch in new code.
val print_backtrace : out_channel -> unitPrintexc.print_backtrace oc prints an exception backtrace on the output channel oc. The backtrace lists the program locations where the most-recently raised exception was raised and where it was propagated through function calls.
If the call is not inside an exception handler, the returned backtrace is unspecified. If the call is after some exception-catching code (before in the handler, or in a when-guard during the matching of the exception handler), the backtrace may correspond to a later exception than the handled one.
Printexc.get_backtrace () returns a string containing the same exception backtrace that Printexc.print_backtrace would print. Same restriction usage than print_backtrace.
Printexc.record_backtrace b turns recording of exception backtraces on (if b = true) or off (if b = false). Initially, backtraces are not recorded, unless the b flag is given to the program through the OCAMLRUNPARAM variable.
Printexc.backtrace_status() returns true if exception backtraces are currently recorded, false if not.
Printexc.register_printer fn registers fn as an exception printer. The printer should return None or raise an exception if it does not know how to convert the passed exception, and Some
+ s with s the resulting string if it can convert the passed exception. Exceptions raised by the printer are ignored.
When converting an exception into a string, the printers will be invoked in the reverse order of their registrations, until a printer returns a Some s value (if no such printer exists, the runtime will use a generic printer).
When using this mechanism, one should be aware that an exception backtrace is attached to the thread that saw it raised, rather than to the exception itself. Practically, it means that the code related to fn should not use the backtrace if it has itself raised an exception before.
Printexc.use_printers e returns None if there are no registered printers and Some s with else as the resulting string otherwise.
The type raw_backtrace stores a backtrace in a low-level format, which can be converted to usable form using raw_backtrace_entries and backtrace_slots_of_raw_entry below.
Converting backtraces to backtrace_slots is slower than capturing the backtraces. If an application processes many backtraces, it can be useful to use raw_backtrace to avoid or delay conversion.
Raw backtraces cannot be marshalled. If you need marshalling, you should use the array returned by the backtrace_slots function of the next section.
A raw_backtrace_entry is an element of a raw_backtrace.
Each raw_backtrace_entry is an opaque integer, whose value is not stable between different programs, or even between different runs of the same binary.
A raw_backtrace_entry can be converted to a usable form using backtrace_slots_of_raw_entry below. Note that, due to inlining, a single raw_backtrace_entry may convert to several backtrace_slots. Since the values of a raw_backtrace_entry are not stable, they cannot be marshalled. If they are to be converted, the conversion must be done by the process that generated them.
Again due to inlining, there may be multiple distinct raw_backtrace_entry values that convert to equal backtrace_slots. However, if two raw_backtrace_entrys are equal as integers, then they represent the same backtrace_slots.
val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry arrayval get_raw_backtrace : unit -> raw_backtracePrintexc.get_raw_backtrace () returns the same exception backtrace that Printexc.print_backtrace would print, but in a raw format. Same restriction usage than print_backtrace.
val print_raw_backtrace : out_channel -> raw_backtrace -> unitPrint a raw backtrace in the same format Printexc.print_backtrace uses.
val raw_backtrace_to_string : raw_backtrace -> stringReturn a string from a raw backtrace, in the same format Printexc.get_backtrace uses.
val raise_with_backtrace : exn -> raw_backtrace -> 'aReraise the exception using the given raw_backtrace for the origin of the exception
val get_callstack : int -> raw_backtracePrintexc.get_callstack n returns a description of the top of the call stack on the current program point (for the current thread), with at most n entries. (Note: this function is not related to exceptions at all, despite being part of the Printexc module.)
val default_uncaught_exception_handler : exn -> raw_backtrace -> unitPrintexc.default_uncaught_exception_handler prints the exception and backtrace on standard error output.
val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unitPrintexc.set_uncaught_exception_handler fn registers fn as the handler for uncaught exceptions. The default handler is Printexc.default_uncaught_exception_handler.
Note that when fn is called all the functions registered with Stdlib.at_exit have already been called. Because of this you must make sure any output channel fn writes on is flushed.
Also note that exceptions raised by user code in the interactive toplevel are not passed to this function as they are caught by the toplevel itself.
If fn raises an exception, both the exceptions passed to fn and raised by fn will be printed with their respective backtrace.
These functions are used to traverse the slots of a raw backtrace and extract information from them in a programmer-friendly format.
val backtrace_slots : raw_backtrace -> backtrace_slot array optionReturns the slots of a raw backtrace, or None if none of them contain useful information.
In the return array, the slot at index 0 corresponds to the most recent function call, raise, or primitive get_backtrace call in the trace.
Some possible reasons for returning None are as follow:
-g)ocamlc -g)val backtrace_slots_of_raw_entry :
+ raw_backtrace_entry ->
+ backtrace_slot array optionReturns the slots of a single raw backtrace entry, or None if this entry lacks debug information.
Slots are returned in the same order as backtrace_slots: the slot at index 0 is the most recent call, raise, or primitive, and subsequent slots represent callers.
The type of location information found in backtraces. start_char and end_char are positions relative to the beginning of the line.
module Slot : sig ... endThis type is used to iterate over the slots of a raw_backtrace. For most purposes, backtrace_slots_of_raw_entry is easier to use.
Like raw_backtrace_entry, values of this type are process-specific and must absolutely not be marshalled, and are unsafe to use for this reason (marshalling them may not fail, but un-marshalling and using the result will result in undefined behavior).
Elements of this type can still be compared and hashed: when two elements are equal, then they represent the same source location (the converse is not necessarily true in presence of inlining, for example).
val raw_backtrace_length : raw_backtrace -> intraw_backtrace_length bckt returns the number of slots in the backtrace bckt.
val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slotget_raw_backtrace_slot bckt pos returns the slot in position pos in the backtrace bckt.
val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slotExtracts the user-friendly backtrace_slot from a low-level raw_backtrace_slot.
val get_raw_backtrace_next_slot :
+ raw_backtrace_slot ->
+ raw_backtrace_slot optionget_raw_backtrace_next_slot slot returns the next slot inlined, if any.
Sample code to iterate over all frames (inlined and non-inlined):
(* Iterate over inlined frames *)
+let rec iter_raw_backtrace_slot f slot =
+ f slot;
+ match get_raw_backtrace_next_slot slot with
+ | None -> ()
+ | Some slot' -> iter_raw_backtrace_slot f slot'
+
+(* Iterate over stack frames *)
+let iter_raw_backtrace f bt =
+ for i = 0 to raw_backtrace_length bt - 1 do
+ iter_raw_backtrace_slot f (get_raw_backtrace_slot bt i)
+ donePrintexc.exn_slot_id returns an integer which uniquely identifies the constructor used to create the exception value exn (in the current runtime).
Stdlib.PrintfFormatted output functions.
val fprintf : out_channel -> ('a, out_channel, unit) format -> 'afprintf outchan format arg1 ... argN formats the arguments arg1 to argN according to the format string format, and outputs the resulting string on the channel outchan.
The format string is a character string which contains two types of objects: plain characters, which are simply copied to the output channel, and conversion specifications, each of which causes conversion and printing of arguments.
Conversion specifications have the following form:
% [flags] [width] [.precision] type
In short, a conversion specification consists in the % character, followed by optional modifiers and a type which is made of one or two characters.
The types and their meanings are:
d, i: convert an integer argument to signed decimal. The flag # adds underscores to large values for readability.u, n, l, L, or N: convert an integer argument to unsigned decimal. Warning: n, l, L, and N are used for scanf, and should not be used for printf. The flag # adds underscores to large values for readability.x: convert an integer argument to unsigned hexadecimal, using lowercase letters. The flag # adds a 0x prefix to non zero values.X: convert an integer argument to unsigned hexadecimal, using uppercase letters. The flag # adds a 0X prefix to non zero values.o: convert an integer argument to unsigned octal. The flag # adds a 0 prefix to non zero values.s: insert a string argument.S: convert a string argument to OCaml syntax (double quotes, escapes).c: insert a character argument.C: convert a character argument to OCaml syntax (single quotes, escapes).f: convert a floating-point argument to decimal notation, in the style dddd.ddd.F: convert a floating-point argument to OCaml syntax (dddd. or dddd.ddd or d.ddd e+-dd). Converts to hexadecimal with the # flag (see h).e or E: convert a floating-point argument to decimal notation, in the style d.ddd e+-dd (mantissa and exponent).g or G: convert a floating-point argument to decimal notation, in style f or e, E (whichever is more compact). Moreover, any trailing zeros are removed from the fractional part of the result and the decimal-point character is removed if there is no fractional part remaining.h or H: convert a floating-point argument to hexadecimal notation, in the style 0xh.hhhh p+-dd (hexadecimal mantissa, exponent in decimal and denotes a power of 2).B: convert a boolean argument to the string true or falseb: convert a boolean argument (deprecated; do not use in new programs).ld, li, lu, lx, lX, lo: convert an int32 argument to the format specified by the second letter (decimal, hexadecimal, etc).nd, ni, nu, nx, nX, no: convert a nativeint argument to the format specified by the second letter.Ld, Li, Lu, Lx, LX, Lo: convert an int64 argument to the format specified by the second letter.a: user-defined printer. Take two arguments and apply the first one to outchan (the current output channel) and to the second argument. The first argument must therefore have type out_channel -> 'b -> unit and the second 'b. The output produced by the function is inserted in the output of fprintf at the current point.t: same as %a, but take only one argument (with type out_channel -> unit) and apply it to outchan.\{ fmt %\}: convert a format string argument to its type digest. The argument must have the same type as the internal format string fmt.( fmt %): format string substitution. Take a format string argument and substitute it to the internal format string fmt to print following arguments. The argument must have the same type as the internal format string fmt.!: take no argument and flush the output.%: take no argument and output one % character.\@: take no argument and output one \@ character.,: take no argument and output nothing: a no-op delimiter for conversion specifications.The optional flags are:
-: left-justify the output (default is right justification).0: for numerical conversions, pad with zeroes instead of spaces.+: for signed numerical conversions, prefix number with a + sign if positive.#: request an alternate formatting style for the integer types and the floating-point type F.The optional width is an integer indicating the minimal width of the result. For instance, %6d prints an integer, prefixing it with spaces to fill at least 6 characters.
The optional precision is a dot . followed by an integer indicating how many digits follow the decimal point in the %f, %e, %E, %h, and %H conversions or the maximum number of significant digits to appear for the %F, %g and %G conversions. For instance, %.4f prints a float with 4 fractional digits.
The integer in a width or precision can also be specified as *, in which case an extra integer argument is taken to specify the corresponding width or precision. This integer argument precedes immediately the argument to print. For instance, %.*f prints a float with as many fractional digits as the value of the argument given before the float.
val printf : ('a, out_channel, unit) format -> 'aSame as Printf.fprintf, but output on stdout.
val eprintf : ('a, out_channel, unit) format -> 'aSame as Printf.fprintf, but output on stderr.
val sprintf : ('a, unit, string) format -> 'aSame as Printf.fprintf, but instead of printing on an output channel, return a string containing the result of formatting the arguments.
Same as Printf.fprintf, but instead of printing on an output channel, append the formatted arguments to the given extensible buffer (see module Buffer).
val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'aSame as Printf.fprintf, but does not print anything. Useful to ignore some material when conditionally printing.
Same as Printf.bprintf, but does not print anything. Useful to ignore some material when conditionally printing.
Formatted output functions with continuations.
val kfprintf :
+ (out_channel -> 'd) ->
+ out_channel ->
+ ('a, out_channel, unit, 'd) format4 ->
+ 'aSame as fprintf, but instead of returning immediately, passes the out channel to its first argument at the end of printing.
val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'aSame as kfprintf above, but does not print anything. Useful to ignore some material when conditionally printing.
val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'aSame as sprintf above, but instead of returning the string, passes it to the first argument.
Same as bprintf, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
Same as kbprintf above, but does not print anything. Useful to ignore some material when conditionally printing.
Deprecated
val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'aA deprecated synonym for ksprintf.
Stdlib.QueueFirst-in first-out queues.
This module implements queues (FIFOs), with in-place modification.
Warning This module is not thread-safe: each Queue.t value must be protected from concurrent access (e.g. with a Mutex.t). Failure to do so can lead to a crash.
Raised when Queue.take or Queue.peek is applied to an empty queue.
val create : unit -> 'a tReturn a new queue, initially empty.
val add : 'a -> 'a t -> unitadd x q adds the element x at the end of the queue q.
val push : 'a -> 'a t -> unitpush is a synonym for add.
val take : 'a t -> 'atake q removes and returns the first element in queue q, or raises Empty if the queue is empty.
val take_opt : 'a t -> 'a optiontake_opt q removes and returns the first element in queue q, or returns None if the queue is empty.
val pop : 'a t -> 'apop is a synonym for take.
val peek : 'a t -> 'apeek q returns the first element in queue q, without removing it from the queue, or raises Empty if the queue is empty.
val peek_opt : 'a t -> 'a optionpeek_opt q returns the first element in queue q, without removing it from the queue, or returns None if the queue is empty.
val top : 'a t -> 'atop is a synonym for peek.
val clear : 'a t -> unitDiscard all elements from a queue.
val is_empty : 'a t -> boolReturn true if the given queue is empty, false otherwise.
val length : 'a t -> intReturn the number of elements in a queue.
val iter : ('a -> unit) -> 'a t -> unititer f q applies f in turn to all elements of q, from the least recently entered to the most recently entered. The queue itself is unchanged.
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'bfold f accu q is equivalent to List.fold_left f accu l, where l is the list of q's elements. The queue remains unchanged.
transfer q1 q2 adds all of q1's elements at the end of the queue q2, then clears q1. It is equivalent to the sequence iter (fun x -> add x q2) q1; clear q1, but runs in constant time.
Iterate on the queue, in front-to-back order. The behavior is not specified if the queue is modified during the iteration.
Random.Stateval make : int array -> tCreate a new state and initialize it with the given seed.
val make_self_init : unit -> tCreate a new state and initialize it with a system-dependent low-entropy seed.
val bits : t -> intval int : t -> int -> intval full_int : t -> int -> intval nativeint : t -> Nativeint.t -> Nativeint.tval float : t -> float -> floatval bool : t -> boolval nativebits : t -> Nativeint.tThese functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one.
Stdlib.RandomPseudo-random number generators (PRNG).
Initialize the generator, using the argument as a seed. The same seed will always yield the same sequence of numbers.
Same as Random.init but takes more data as seed.
Initialize the generator with a random seed chosen in a system-dependent way. If /dev/urandom is available on the host machine, it is used to provide a highly random initial seed. Otherwise, a less random seed is computed from system parameters (current time, process IDs).
Random.int bound returns a random integer between 0 (inclusive) and bound (exclusive). bound must be greater than 0 and less than 230.
Random.full_int bound returns a random integer between 0 (inclusive) and bound (exclusive). bound may be any positive integer.
If bound is less than 230, Random.full_int bound is equal to Random.int bound. If bound is greater than 230 (on 64-bit systems or non-standard environments, such as JavaScript), Random.full_int returns a value, where Random.int raises Invalid_argument.
Random.int32 bound returns a random integer between 0 (inclusive) and bound (exclusive). bound must be greater than 0.
val nativeint : Nativeint.t -> Nativeint.tRandom.nativeint bound returns a random integer between 0 (inclusive) and bound (exclusive). bound must be greater than 0.
Random.int64 bound returns a random integer between 0 (inclusive) and bound (exclusive). bound must be greater than 0.
Random.float bound returns a random floating-point number between 0 and bound (inclusive). If bound is negative, the result is negative or zero. If bound is 0, the result is 0.
val bits32 : unit -> Int32.tRandom.bits32 () returns 32 random bits as an integer between Int32.min_int and Int32.max_int.
val bits64 : unit -> Int64.tRandom.bits64 () returns 64 random bits as an integer between Int64.min_int and Int64.max_int.
val nativebits : unit -> Nativeint.tRandom.nativebits () returns 32 or 64 random bits (depending on the bit width of the platform) as an integer between Nativeint.min_int and Nativeint.max_int.
The functions from module State manipulate the current state of the random generator explicitly. This allows using one or several deterministic PRNGs, even in a multi-threaded program, without interference from other parts of the program.
module State : sig ... endval get_state : unit -> State.tReturn the current state of the generator used by the basic functions.
val set_state : State.t -> unitSet the state of the generator used by the basic functions.
Stdlib.ResultResult values.
Result values handle computation results and errors in an explicit and declarative manner without resorting to exceptions.
The type for result values. Either a value Ok v or an error Error e.
val ok : 'a -> ('a, 'e) resultok v is Ok v.
val error : 'e -> ('a, 'e) resulterror e is Error e.
val value : ('a, 'e) result -> default:'a -> 'avalue r ~default is v if r is Ok v and default otherwise.
val get_ok : ('a, 'e) result -> 'aget_ok r is v if r is Ok v and raise otherwise.
val get_error : ('a, 'e) result -> 'eget_error r is e if r is Error e and raise otherwise.
bind r f is f v if r is Ok v and r if r is Error _.
join rr is r if rr is Ok r and rr if rr is Error _.
map f r is Ok (f v) if r is Ok v and r if r is Error _.
map_error f r is Error (f e) if r is Error e and r if r is Ok _.
val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'cfold ~ok ~error r is ok v if r is Ok v and error e if r is Error e.
val iter : ('a -> unit) -> ('a, 'e) result -> unititer f r is f v if r is Ok v and () otherwise.
val iter_error : ('e -> unit) -> ('a, 'e) result -> unititer_error f r is f e if r is Error e and () otherwise.
val is_ok : ('a, 'e) result -> boolis_ok r is true if and only if r is Ok _.
val is_error : ('a, 'e) result -> boolis_error r is true if and only if r is Error _.
val equal :
+ ok:('a -> 'a -> bool) ->
+ error:('e -> 'e -> bool) ->
+ ('a, 'e) result ->
+ ('a, 'e) result ->
+ boolequal ~ok ~error r0 r1 tests equality of r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _.
val compare :
+ ok:('a -> 'a -> int) ->
+ error:('e -> 'e -> int) ->
+ ('a, 'e) result ->
+ ('a, 'e) result ->
+ intcompare ~ok ~error r0 r1 totally orders r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _. Ok _ values are smaller than Error _ values.
val to_option : ('a, 'e) result -> 'a optionto_option r is r as an option, mapping Ok v to Some v and Error _ to None.
val to_list : ('a, 'e) result -> 'a listto_list r is [v] if r is Ok v and [] otherwise.
Scanf.ScanningThe notion of input channel for the Scanf module: those channels provide all the machinery necessary to read from any source of characters, including a Stdlib.in_channel value. A Scanf.Scanning.in_channel value is also called a formatted input channel or equivalently a scanning buffer. The type Scanning.scanbuf below is an alias for Scanning.in_channel.
type scanbuf = in_channelThe type of scanning buffers. A scanning buffer is the source from which a formatted input function gets characters. The scanning buffer holds the current state of the scan, plus a function to get the next char from the input, and a token buffer to store the string matched so far.
Note: a scanning action may often require to examine one character in advance; when this 'lookahead' character does not belong to the token read, it is stored back in the scanning buffer and becomes the next character yet to be read.
val stdin : in_channelThe standard input notion for the Scanf module. Scanning.stdin is the Scanning.in_channel formatted input channel attached to Stdlib.stdin.
Note: in the interactive system, when input is read from Stdlib.stdin, the newline character that triggers evaluation is part of the input; thus, the scanning specifications must properly skip this additional newline character (for instance, simply add a '\n' as the last character of the format string).
val open_in : file_name -> in_channelScanning.open_in fname returns a Scanning.in_channel formatted input channel for bufferized reading in text mode from file fname.
Note: open_in returns a formatted input channel that efficiently reads characters in large chunks; in contrast, from_channel below returns formatted input channels that must read one character at a time, leading to a much slower scanning rate.
val open_in_bin : file_name -> in_channelScanning.open_in_bin fname returns a Scanning.in_channel formatted input channel for bufferized reading in binary mode from file fname.
val close_in : in_channel -> unitCloses the Stdlib.in_channel associated with the given Scanning.in_channel formatted input channel.
val from_file : file_name -> in_channelAn alias for Scanning.open_in above.
val from_file_bin : string -> in_channelAn alias for Scanning.open_in_bin above.
val from_string : string -> in_channelScanning.from_string s returns a Scanning.in_channel formatted input channel which reads from the given string. Reading starts from the first character in the string. The end-of-input condition is set when the end of the string is reached.
val from_function : (unit -> char) -> in_channelScanning.from_function f returns a Scanning.in_channel formatted input channel with the given function as its reading method.
When scanning needs one more character, the given function is called.
When the function has no more character to provide, it must signal an end-of-input condition by raising the exception End_of_file.
val from_channel : in_channel -> in_channelScanning.from_channel ic returns a Scanning.in_channel formatted input channel which reads from the regular Stdlib.in_channel input channel ic argument. Reading starts at current reading position of ic.
val end_of_input : in_channel -> boolScanning.end_of_input ic tests the end-of-input condition of the given Scanning.in_channel formatted input channel.
val beginning_of_input : in_channel -> boolScanning.beginning_of_input ic tests the beginning of input condition of the given Scanning.in_channel formatted input channel.
val name_of_input : in_channel -> stringScanning.name_of_input ic returns the name of the character source for the given Scanning.in_channel formatted input channel.
val stdib : in_channelA deprecated alias for Scanning.stdin, the scanning buffer reading from Stdlib.stdin.
Stdlib.ScanfFormatted input functions.
The module Scanf provides formatted input functions or scanners.
The formatted input functions can read from any kind of input, including strings, files, or anything that can return characters. The more general source of characters is named a formatted input channel (or scanning buffer) and has type Scanning.in_channel. The more general formatted input function reads from any scanning buffer and is named bscanf.
Generally speaking, the formatted input functions have 3 arguments:
Hence, a typical call to the formatted input function Scanf.bscanf is bscanf ic fmt f, where:
ic is a source of characters (typically a formatted input channel with type Scanning.in_channel),fmt is a format string (the same format strings as those used to print material with module Printf or Format),f is a function that has as many arguments as the number of values to read in the input according to fmt.As suggested above, the expression bscanf ic "%d" f reads a decimal integer n from the source of characters ic and returns f n.
For instance,
stdin as the source of characters (Scanning.stdin is the predefined formatted input channel that reads from standard input),f as let f x = x + 1,then bscanf Scanning.stdin "%d" f reads an integer n from the standard input and returns f n (that is n + 1). Thus, if we evaluate bscanf stdin "%d" f, and then enter 41 at the keyboard, the result we get is 42.
The OCaml scanning facility is reminiscent of the corresponding C feature. However, it is also largely different, simpler, and yet more powerful: the formatted input functions are higher-order functionals and the parameter passing mechanism is just the regular function application not the variable assignment based mechanism which is typical for formatted input in imperative languages; the OCaml format strings also feature useful additions to easily define complex tokens; as expected within a functional programming language, the formatted input functions also support polymorphism, in particular arbitrary interaction with polymorphic user-defined scanners. Furthermore, the OCaml formatted input facility is fully type-checked at compile time.
module Scanning : sig ... endtype ('a, 'b, 'c, 'd) scanner =
+ ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 ->
+ 'cThe type of formatted input scanners: ('a, 'b, 'c, 'd) scanner is the type of a formatted input function that reads from some formatted input channel according to some format string; more precisely, if scan is some formatted input function, then scan
+ ic fmt f applies f to all the arguments specified by format string fmt, when scan has read those arguments from the Scanning.in_channel formatted input channel ic.
For instance, the Scanf.scanf function below has type ('a, 'b, 'c, 'd) scanner, since it is a formatted input function that reads from Scanning.stdin: scanf fmt f applies f to the arguments specified by fmt, reading those arguments from Stdlib.stdin as expected.
If the format fmt has some %r indications, the corresponding formatted input functions must be provided before receiver function f. For instance, if read_elem is an input function for values of type t, then bscanf ic "%r;" read_elem f reads a value v of type t followed by a ';' character, and returns f v.
When the input can not be read according to the format string specification, formatted input functions typically raise exception Scan_failure.
val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scannerbscanf ic fmt r1 ... rN f reads characters from the Scanning.in_channel formatted input channel ic and converts them to values according to format string fmt. As a final step, receiver function f is applied to the values read and gives the result of the bscanf call.
For instance, if f is the function fun s i -> i + 1, then Scanf.sscanf "x= 1" "%s = %i" f returns 2.
Arguments r1 to rN are user-defined input functions that read the argument corresponding to the %r conversions specified in the format string.
The format string is a character string which contains three types of objects:
space),f (see conversion),indication).As mentioned above, a plain character in the format string is just matched with the next character of the input; however, two characters are special exceptions to this rule: the space character (' ' or ASCII code 32) and the line feed character ('\n' or ASCII code 10). A space does not match a single space character, but any amount of 'whitespace' in the input. More precisely, a space inside the format string matches any number of tab, space, line feed and carriage return characters. Similarly, a line feed character in the format string matches either a single line feed or a carriage return followed by a line feed.
Matching any amount of whitespace, a space in the format string also matches no amount of whitespace at all; hence, the call bscanf ib
+ "Price = %d $" (fun p -> p) succeeds and returns 1 when reading an input with various whitespace in it, such as Price = 1 $, Price = 1 $, or even Price=1$.
Conversion specifications consist in the % character, followed by an optional flag, an optional field width, and followed by one or two conversion characters.
The conversion characters and their meanings are:
d: reads an optionally signed decimal integer (0-9+).i: reads an optionally signed integer (usual input conventions for decimal (0-9+), hexadecimal (0x[0-9a-f]+ and 0X[0-9A-F]+), octal (0o[0-7]+), and binary (0b[0-1]+) notations are understood).u: reads an unsigned decimal integer.x or X: reads an unsigned hexadecimal integer ([0-9a-fA-F]+).o: reads an unsigned octal integer ([0-7]+).s: reads a string argument that spreads as much as possible, until the following bounding condition holds:
space),indication) has been encountered,Hence, this conversion always succeeds: it returns an empty string if the bounding condition holds when the scan begins.
S: reads a delimited string argument (delimiters and special escaped characters follow the lexical conventions of OCaml).c: reads a single character. To test the current input character without reading it, specify a null field width, i.e. use specification %0c. Raise Invalid_argument, if the field width specification is greater than 1.C: reads a single delimited character (delimiters and special escaped characters follow the lexical conventions of OCaml).f, e, E, g, G: reads an optionally signed floating-point number in decimal notation, in the style dddd.ddd
+ e/E+-dd.h, H: reads an optionally signed floating-point number in hexadecimal notation.F: reads a floating point number according to the lexical conventions of OCaml (hence the decimal point is mandatory if the exponent part is not mentioned).B: reads a boolean argument (true or false).b: reads a boolean argument (for backward compatibility; do not use in new programs).ld, li, lu, lx, lX, lo: reads an int32 argument to the format specified by the second letter for regular integers.nd, ni, nu, nx, nX, no: reads a nativeint argument to the format specified by the second letter for regular integers.Ld, Li, Lu, Lx, LX, Lo: reads an int64 argument to the format specified by the second letter for regular integers.[ range ]: reads characters that matches one of the characters mentioned in the range of characters range (or not mentioned in it, if the range starts with ^). Reads a string that can be empty, if the next input character does not match the range. The set of characters from c1 to c2 (inclusively) is denoted by c1-c2. Hence, %[0-9] returns a string representing a decimal number or an empty string if no decimal digit is found; similarly, %[0-9a-f] returns a string of hexadecimal digits. If a closing bracket appears in a range, it must occur as the first character of the range (or just after the ^ in case of range negation); hence []] matches a ] character and [^]] matches any character that is not ]. Use %% and %@ to include a % or a @ in a range.r: user-defined reader. Takes the next ri formatted input function and applies it to the scanning buffer ib to read the next argument. The input function ri must therefore have type Scanning.in_channel -> 'a and the argument read has type 'a.{ fmt %}: reads a format string argument. The format string read must have the same type as the format string specification fmt. For instance, "%{ %i %}" reads any format string that can read a value of type int; hence, if s is the string "fmt:\"number is %u\"", then Scanf.sscanf s "fmt: %{%i%}" succeeds and returns the format string "number is %u".( fmt %): scanning sub-format substitution. Reads a format string rf in the input, then goes on scanning with rf instead of scanning with fmt. The format string rf must have the same type as the format string specification fmt that it replaces. For instance, "%( %i %)" reads any format string that can read a value of type int. The conversion returns the format string read rf, and then a value read using rf. Hence, if s is the string "\"%4d\"1234.00", then Scanf.sscanf s "%(%i%)" (fun fmt i -> fmt, i) evaluates to ("%4d", 1234). This behaviour is not mere format substitution, since the conversion returns the format string read as additional argument. If you need pure format substitution, use special flag _ to discard the extraneous argument: conversion %_( fmt %) reads a format string rf and then behaves the same as format string rf. Hence, if s is the string "\"%4d\"1234.00", then Scanf.sscanf s "%_(%i%)" is simply equivalent to Scanf.sscanf "1234.00" "%4d".l: returns the number of lines read so far.n: returns the number of characters read so far.N or L: returns the number of tokens read so far.!: matches the end of input condition.%: matches one % character in the input.@: matches one @ character in the input.,: does nothing.Following the % character that introduces a conversion, there may be the special flag _: the conversion that follows occurs as usual, but the resulting value is discarded. For instance, if f is the function fun i -> i + 1, and s is the string "x = 1", then Scanf.sscanf s "%_s = %i" f returns 2.
The field width is composed of an optional integer literal indicating the maximal width of the token to read. For instance, %6d reads an integer, having at most 6 decimal digits; %4f reads a float with at most 4 characters; and %8[\000-\255] returns the next 8 characters (or all the characters still available, if fewer than 8 characters are available in the input).
Notes:
%s conversion always succeeds, even if there is nothing to read in the input: in this case, it simply returns "".'_' characters may appear inside numbers (this is reminiscent to the usual OCaml lexical conventions). If stricter scanning is desired, use the range conversion facility instead of the number conversions.scanf facility is not intended for heavy duty lexical analysis and parsing. If it appears not expressive enough for your needs, several alternative exists: regular expressions (module Str), stream parsers, ocamllex-generated lexers, ocamlyacc-generated parsers.Scanning indications appear just after the string conversions %s and %[ range ] to delimit the end of the token. A scanning indication is introduced by a @ character, followed by some plain character c. It means that the string token should end just before the next matching c (which is skipped). If no c character is encountered, the string token spreads as much as possible. For instance, "%s@\t" reads a string up to the next tab character or to the end of input. If a @ character appears anywhere else in the format string, it is treated as a plain character.
Note:
% and @ characters must be escaped using %% and %@; this rule still holds within range specifications and scanning indications. For instance, format "%s@%%" reads a string up to the next % character, and format "%s@%@" reads a string up to the next @.Scanf format strings, compared to those used for the Printf module. However, the scanning indications are similar to those used in the Format module; hence, when producing formatted text to be scanned by Scanf.bscanf, it is wise to use printing functions from the Format module (or, if you need to use functions from Printf, banish or carefully double check the format strings that contain '@' characters).Scanners may raise the following exceptions when the input cannot be read according to the format string:
Scanf.Scan_failure if the input does not match the format.Failure if a conversion to a number is not possible.End_of_file if the end of input is encountered while some more characters are needed to read the current conversion specification.Invalid_argument if the format string is invalid.Note:
%s conversion never raises exception End_of_file: if the end of input is reached the conversion succeeds and simply returns the characters read so far, or "" if none were ever read.val sscanf : string -> ('a, 'b, 'c, 'd) scannerSame as Scanf.bscanf, but reads from the given string.
val scanf : ('a, 'b, 'c, 'd) scannerSame as Scanf.bscanf, but reads from the predefined formatted input channel Scanf.Scanning.stdin that is connected to Stdlib.stdin.
val kscanf :
+ Scanning.in_channel ->
+ (Scanning.in_channel -> exn -> 'd) ->
+ ('a, 'b, 'c, 'd) scannerSame as Scanf.bscanf, but takes an additional function argument ef that is called in case of error: if the scanning process or some conversion fails, the scanning function aborts and calls the error handling function ef with the formatted input channel and the exception that aborted the scanning process as arguments.
val ksscanf :
+ string ->
+ (Scanning.in_channel -> exn -> 'd) ->
+ ('a, 'b, 'c, 'd) scannerSame as Scanf.kscanf but reads from the given string.
val bscanf_format :
+ Scanning.in_channel ->
+ ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
+ (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) ->
+ 'gbscanf_format ic fmt f reads a format string token from the formatted input channel ic, according to the given format string fmt, and applies f to the resulting format string value.
val sscanf_format :
+ string ->
+ ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
+ (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) ->
+ 'gSame as Scanf.bscanf_format, but reads from the given string.
val format_from_string :
+ string ->
+ ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
+ ('a, 'b, 'c, 'd, 'e, 'f) format6format_from_string s fmt converts a string argument to a format string, according to the given format string fmt.
unescaped s return a copy of s with escape sequences (according to the lexical conventions of OCaml) replaced by their corresponding special characters. More precisely, Scanf.unescaped has the following property: for all string s, Scanf.unescaped (String.escaped s) = s.
Always return a copy of the argument, even if there is no escape sequence in the argument.
val fscanf : in_channel -> ('a, 'b, 'c, 'd) scannerval kfscanf :
+ in_channel ->
+ (Scanning.in_channel -> exn -> 'd) ->
+ ('a, 'b, 'c, 'd) scannerStdlib.SeqSequences.
A sequence of type 'a Seq.t can be thought of as a delayed list, that is, a list whose elements are computed only when they are demanded by a consumer. This allows sequences to be produced and transformed lazily (one element at a time) rather than eagerly (all elements at once). This also allows constructing conceptually infinite sequences.
The type 'a Seq.t is defined as a synonym for unit -> 'a Seq.node. This is a function type: therefore, it is opaque. The consumer can query a sequence in order to request the next element (if there is one), but cannot otherwise inspect the sequence in any way.
Because it is opaque, the type 'a Seq.t does not reveal whether a sequence is:
It also does not reveal whether the elements of the sequence are:
It is up to the programmer to keep these distinctions in mind so as to understand the time and space requirements of sequences.
For the sake of simplicity, most of the documentation that follows is written under the implicit assumption that the sequences at hand are persistent. We normally do not point out when or how many times each function is invoked, because that would be too verbose. For instance, in the description of map, we write: "if xs is the sequence x0; x1; ... then map f xs is the sequence f x0; f x1; ...". If we wished to be more explicit, we could point out that the transformation takes place on demand: that is, the elements of map f xs are computed only when they are demanded. In other words, the definition let ys = map f xs terminates immediately and does not invoke f. The function call f x0 takes place only when the first element of ys is demanded, via the function call ys(). Furthermore, calling ys() twice causes f x0 to be called twice as well. If one wishes for f to be applied at most once to each element of xs, even in scenarios where ys is queried more than once, then one should use let ys = memoize (map f xs).
As a general rule, the functions that build sequences, such as map, filter, scan, take, etc., produce sequences whose elements are computed only on demand. The functions that eagerly consume sequences, such as is_empty, find, length, iter, fold_left, etc., are the functions that force computation to take place.
When possible, we recommend using sequences rather than dispensers (functions of type unit -> 'a option that produce elements upon demand). Whereas sequences can be persistent or ephemeral, dispensers are always ephemeral, and are typically more difficult to work with than sequences. Two conversion functions, to_dispenser and of_dispenser, are provided.
type 'a t = unit -> 'a nodeA sequence xs of type 'a t is a delayed list of elements of type 'a. Such a sequence is queried by performing a function application xs(). This function application returns a node, allowing the caller to determine whether the sequence is empty or nonempty, and in the latter case, to obtain its head and tail.
A node is either Nil, which means that the sequence is empty, or Cons (x, xs), which means that x is the first element of the sequence and that xs is the remainder of the sequence.
The functions in this section consume their argument, a sequence, either partially or completely:
is_empty and uncons consume the sequence down to depth 1. That is, they demand the first argument of the sequence, if there is one.iter, fold_left, length, etc., consume the sequence all the way to its end. They terminate only if the sequence is finite.for_all, exists, find, etc. consume the sequence down to a certain depth, which is a priori unpredictable.Similarly, among the functions that consume two sequences, one can distinguish two groups:
iter2 and fold_left2 consume both sequences all the way to the end, provided the sequences have the same length.for_all2, exists2, equal, compare consume the sequences down to a certain depth, which is a priori unpredictable.The functions that consume two sequences can be applied to two sequences of distinct lengths: in that case, the excess elements in the longer sequence are ignored. (It may be the case that one excess element is demanded, even though this element is not used.)
None of the functions in this section is lazy. These functions are consumers: they force some computation to take place.
val is_empty : 'a t -> boolis_empty xs determines whether the sequence xs is empty.
It is recommended that the sequence xs be persistent. Indeed, is_empty xs demands the head of the sequence xs, so, if xs is ephemeral, it may be the case that xs cannot be used any more after this call has taken place.
If xs is empty, then uncons xs is None.
If xs is nonempty, then uncons xs is Some (head xs, tail xs), that is, a pair of the head and tail of the sequence xs.
This equivalence holds if xs is persistent. If xs is ephemeral, then uncons must be preferred over separate calls to head and tail, which would cause xs to be queried twice.
val length : 'a t -> intlength xs is the length of the sequence xs.
The sequence xs must be finite.
val iter : ('a -> unit) -> 'a t -> unititer f xs invokes f x successively for every element x of the sequence xs, from left to right.
It terminates only if the sequence xs is finite.
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'afold_left f _ xs invokes f _ x successively for every element x of the sequence xs, from left to right.
An accumulator of type 'a is threaded through the calls to f.
It terminates only if the sequence xs is finite.
val iteri : (int -> 'a -> unit) -> 'a t -> unititeri f xs invokes f i x successively for every element x located at index i in the sequence xs.
It terminates only if the sequence xs is finite.
iteri f xs is equivalent to iter (fun (i, x) -> f i x) (zip (ints 0) xs).
val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'bfold_lefti f _ xs invokes f _ i x successively for every element x located at index i of the sequence xs.
An accumulator of type 'b is threaded through the calls to f.
It terminates only if the sequence xs is finite.
fold_lefti f accu xs is equivalent to fold_left (fun accu (i, x) -> f accu i x) accu (zip (ints 0) xs).
val for_all : ('a -> bool) -> 'a t -> boolfor_all p xs determines whether all elements x of the sequence xs satisfy p x.
The sequence xs must be finite.
val exists : ('a -> bool) -> 'a t -> boolexists xs p determines whether at least one element x of the sequence xs satisfies p x.
The sequence xs must be finite.
val find : ('a -> bool) -> 'a t -> 'a optionfind p xs returns Some x, where x is the first element of the sequence xs that satisfies p x, if there is such an element.
It returns None if there is no such element.
The sequence xs must be finite.
val find_map : ('a -> 'b option) -> 'a t -> 'b optionfind_map f xs returns Some y, where x is the first element of the sequence xs such that f x = Some _, if there is such an element, and where y is defined by f x = Some y.
It returns None if there is no such element.
The sequence xs must be finite.
iter2 f xs ys invokes f x y successively for every pair (x, y) of elements drawn synchronously from the sequences xs and ys.
If the sequences xs and ys have different lengths, then iteration stops as soon as one sequence is exhausted; the excess elements in the other sequence are ignored.
Iteration terminates only if at least one of the sequences xs and ys is finite.
iter2 f xs ys is equivalent to iter (fun (x, y) -> f x y) (zip xs ys).
fold_left2 f _ xs ys invokes f _ x y successively for every pair (x, y) of elements drawn synchronously from the sequences xs and ys.
An accumulator of type 'a is threaded through the calls to f.
If the sequences xs and ys have different lengths, then iteration stops as soon as one sequence is exhausted; the excess elements in the other sequence are ignored.
Iteration terminates only if at least one of the sequences xs and ys is finite.
fold_left2 f accu xs ys is equivalent to fold_left (fun accu (x, y) -> f accu x y) (zip xs ys).
for_all2 p xs ys determines whether all pairs (x, y) of elements drawn synchronously from the sequences xs and ys satisfy p x y.
If the sequences xs and ys have different lengths, then iteration stops as soon as one sequence is exhausted; the excess elements in the other sequence are ignored. In particular, if xs or ys is empty, then for_all2 p xs ys is true. This is where for_all2 and equal differ: equal eq xs ys can be true only if xs and ys have the same length.
At least one of the sequences xs and ys must be finite.
for_all2 p xs ys is equivalent to for_all (fun b -> b) (map2 p xs ys).
exists2 p xs ys determines whether some pair (x, y) of elements drawn synchronously from the sequences xs and ys satisfies p x y.
If the sequences xs and ys have different lengths, then iteration must stop as soon as one sequence is exhausted; the excess elements in the other sequence are ignored.
At least one of the sequences xs and ys must be finite.
exists2 p xs ys is equivalent to exists (fun b -> b) (map2 p xs ys).
Provided the function eq defines an equality on elements, equal eq xs ys determines whether the sequences xs and ys are pointwise equal.
At least one of the sequences xs and ys must be finite.
Provided the function cmp defines a preorder on elements, compare cmp xs ys compares the sequences xs and ys according to the lexicographic preorder.
For more details on comparison functions, see Array.sort.
At least one of the sequences xs and ys must be finite.
The functions in this section are lazy: that is, they return sequences whose elements are computed only when demanded.
val empty : 'a tempty is the empty sequence. It has no elements. Its length is 0.
val return : 'a -> 'a treturn x is the sequence whose sole element is x. Its length is 1.
cons x xs is the sequence that begins with the element x, followed with the sequence xs.
Writing cons (f()) xs causes the function call f() to take place immediately. For this call to be delayed until the sequence is queried, one must instead write (fun () -> Cons(f(), xs)).
val init : int -> (int -> 'a) -> 'a tinit n f is the sequence f 0; f 1; ...; f (n-1).
n must be nonnegative.
If desired, the infinite sequence f 0; f 1; ... can be defined as map f (ints 0).
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a tunfold constructs a sequence out of a step function and an initial state.
If f u is None then unfold f u is the empty sequence. If f u is Some (x, u') then unfold f u is the nonempty sequence cons x (unfold f u').
For example, unfold (function [] -> None | h :: t -> Some (h, t)) l is equivalent to List.to_seq l.
val repeat : 'a -> 'a trepeat x is the infinite sequence where the element x is repeated indefinitely.
repeat x is equivalent to cycle (return x).
val forever : (unit -> 'a) -> 'a tforever f is an infinite sequence where every element is produced (on demand) by the function call f().
For instance, forever Random.bool is an infinite sequence of random bits.
forever f is equivalent to map f (repeat ()).
cycle xs is the infinite sequence that consists of an infinite number of repetitions of the sequence xs.
If xs is an empty sequence, then cycle xs is empty as well.
Consuming (a prefix of) the sequence cycle xs once can cause the sequence xs to be consumed more than once. Therefore, xs must be persistent.
val iterate : ('a -> 'a) -> 'a -> 'a titerate f x is the infinite sequence whose elements are x, f x, f (f x), and so on.
In other words, it is the orbit of the function f, starting at x.
The functions in this section are lazy: that is, they return sequences whose elements are computed only when demanded.
map f xs is the image of the sequence xs through the transformation f.
If xs is the sequence x0; x1; ... then map f xs is the sequence f x0; f x1; ....
mapi is analogous to map, but applies the function f to an index and an element.
mapi f xs is equivalent to map2 f (ints 0) xs.
filter p xs is the sequence of the elements x of xs that satisfy p x.
In other words, filter p xs is the sequence xs, deprived of the elements x such that p x is false.
filter_map f xs is the sequence of the elements y such that f x = Some y, where x ranges over xs.
filter_map f xs is equivalent to map Option.get (filter Option.is_some (map f xs)).
If xs is a sequence [x0; x1; x2; ...], then scan f a0 xs is a sequence of accumulators [a0; a1; a2; ...] where a1 is f a0 x0, a2 is f a1 x1, and so on.
Thus, scan f a0 xs is conceptually related to fold_left f a0 xs. However, instead of performing an eager iteration and immediately returning the final accumulator, it returns a sequence of accumulators.
For instance, scan (+) 0 transforms a sequence of integers into the sequence of its partial sums.
If xs has length n then scan f a0 xs has length n+1.
take n xs is the sequence of the first n elements of xs.
If xs has fewer than n elements, then take n xs is equivalent to xs.
n must be nonnegative.
drop n xs is the sequence xs, deprived of its first n elements.
If xs has fewer than n elements, then drop n xs is empty.
n must be nonnegative.
drop is lazy: the first n+1 elements of the sequence xs are demanded only when the first element of drop n xs is demanded. For this reason, drop 1 xs is not equivalent to tail xs, which queries xs immediately.
take_while p xs is the longest prefix of the sequence xs where every element x satisfies p x.
drop_while p xs is the sequence xs, deprived of the prefix take_while p xs.
Provided the function eq defines an equality on elements, group eq xs is the sequence of the maximal runs of adjacent duplicate elements of the sequence xs.
Every element of group eq xs is a nonempty sequence of equal elements.
The concatenation concat (group eq xs) is equal to xs.
Consuming group eq xs, and consuming the sequences that it contains, can cause xs to be consumed more than once. Therefore, xs must be persistent.
The sequence memoize xs has the same elements as the sequence xs.
Regardless of whether xs is ephemeral or persistent, memoize xs is persistent: even if it is queried several times, xs is queried at most once.
The construction of the sequence memoize xs internally relies on suspensions provided by the module Lazy. These suspensions are not thread-safe. Therefore, the sequence memoize xs must not be queried by multiple threads concurrently.
This exception is raised when a sequence returned by once (or a suffix of it) is queried more than once.
The sequence once xs has the same elements as the sequence xs.
Regardless of whether xs is ephemeral or persistent, once xs is an ephemeral sequence: it can be queried at most once. If it (or a suffix of it) is queried more than once, then the exception Forced_twice is raised. This can be useful, while debugging or testing, to ensure that a sequence is consumed at most once.
If xss is a matrix (a sequence of rows), then transpose xss is the sequence of the columns of the matrix xss.
The rows of the matrix xss are not required to have the same length.
The matrix xss is not required to be finite (in either direction).
The matrix xss must be persistent.
append xs ys is the concatenation of the sequences xs and ys.
Its elements are the elements of xs, followed by the elements of ys.
If xss is a sequence of sequences, then concat xss is its concatenation.
If xss is the sequence xs0; xs1; ... then concat xss is the sequence xs0 @ xs1 @ ....
concat_map f xs is equivalent to concat (map f xs).
concat_map is an alias for flat_map.
zip xs ys is the sequence of pairs (x, y) drawn synchronously from the sequences xs and ys.
If the sequences xs and ys have different lengths, then the sequence ends as soon as one sequence is exhausted; the excess elements in the other sequence are ignored.
zip xs ys is equivalent to map2 (fun a b -> (a, b)) xs ys.
map2 f xs ys is the sequence of the elements f x y, where the pairs (x, y) are drawn synchronously from the sequences xs and ys.
If the sequences xs and ys have different lengths, then the sequence ends as soon as one sequence is exhausted; the excess elements in the other sequence are ignored.
map2 f xs ys is equivalent to map (fun (x, y) -> f x y) (zip xs ys).
interleave xs ys is the sequence that begins with the first element of xs, continues with the first element of ys, and so on.
When one of the sequences xs and ys is exhausted, interleave xs ys continues with the rest of the other sequence.
If the sequences xs and ys are sorted according to the total preorder cmp, then sorted_merge cmp xs ys is the sorted sequence obtained by merging the sequences xs and ys.
For more details on comparison functions, see Array.sort.
product xs ys is the Cartesian product of the sequences xs and ys.
For every element x of xs and for every element y of ys, the pair (x, y) appears once as an element of product xs ys.
The order in which the pairs appear is unspecified.
The sequences xs and ys are not required to be finite.
The sequences xs and ys must be persistent.
The sequence map_product f xs ys is the image through f of the Cartesian product of the sequences xs and ys.
For every element x of xs and for every element y of ys, the element f x y appears once as an element of map_product f xs ys.
The order in which these elements appear is unspecified.
The sequences xs and ys are not required to be finite.
The sequences xs and ys must be persistent.
map_product f xs ys is equivalent to map (fun (x, y) -> f x y) (product xs ys).
unzip transforms a sequence of pairs into a pair of sequences.
unzip xs is equivalent to (map fst xs, map snd xs).
Querying either of the sequences returned by unzip xs causes xs to be queried. Therefore, querying both of them causes xs to be queried twice. Thus, xs must be persistent and cheap. If that is not the case, use unzip (memoize xs).
partition_map f xs returns a pair of sequences (ys, zs), where:
ys is the sequence of the elements y such that f x = Left y, where x ranges over xs;zs is the sequence of the elements z such that f x = Right z, where x ranges over xs.partition_map f xs is equivalent to a pair of filter_map Either.find_left (map f xs) and filter_map Either.find_right (map f xs).
Querying either of the sequences returned by partition_map f xs causes xs to be queried. Therefore, querying both of them causes xs to be queried twice. Thus, xs must be persistent and cheap. If that is not the case, use partition_map f (memoize xs).
partition p xs returns a pair of the subsequence of the elements of xs that satisfy p and the subsequence of the elements of xs that do not satisfy p.
partition p xs is equivalent to filter p xs, filter (fun x -> not (p x)) xs.
Consuming both of the sequences returned by partition p xs causes xs to be consumed twice and causes the function f to be applied twice to each element of the list. Therefore, f should be pure and cheap. Furthermore, xs should be persistent and cheap. If that is not the case, use partition p (memoize xs).
A dispenser is a representation of a sequence as a function of type unit -> 'a option. Every time this function is invoked, it returns the next element of the sequence. When there are no more elements, it returns None. A dispenser has mutable internal state, therefore is ephemeral: the sequence that it represents can be consumed at most once.
val of_dispenser : (unit -> 'a option) -> 'a tof_dispenser it is the sequence of the elements produced by the dispenser it. It is an ephemeral sequence: it can be consumed at most once. If a persistent sequence is needed, use memoize (of_dispenser it).
val to_dispenser : 'a t -> unit -> 'a optionto_dispenser xs is a fresh dispenser on the sequence xs.
This dispenser has mutable internal state, which is not protected by a lock; so, it must not be used by several threads concurrently.
val ints : int -> int tints i is the infinite sequence of the integers beginning at i and counting up.
Make.OrdA total ordering function over the set elements. This is a two-argument function f such that f e1 e2 is zero if the elements e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Set.MakeFunctor building an implementation of the set structure given a totally ordered type.
module Ord : OrderedTypetype elt = Ord.tThe type of the set elements.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Stdlib.SetSets over ordered types.
This module implements the set data structure, given a total ordering function over the set elements. All operations over sets are purely applicative (no side-effects). The implementation uses balanced binary trees, and is therefore reasonably efficient: insertion and membership take time logarithmic in the size of the set, for instance.
The Make functor constructs implementations for any type, given a compare function. For instance:
module IntPairs =
+ struct
+ type t = int * int
+ let compare (x0,y0) (x1,y1) =
+ match Stdlib.compare x0 x1 with
+ 0 -> Stdlib.compare y0 y1
+ | c -> c
+ end
+
+module PairsSet = Set.Make(IntPairs)
+
+let m = PairsSet.(empty |> add (2,3) |> add (5,7) |> add (11,13))This creates a new module PairsSet, with a new type PairsSet.t of sets of int * int.
module type OrderedType = sig ... endInput signature of the functor Make.
Set.OrderedTypeInput signature of the functor Make.
A total ordering function over the set elements. This is a two-argument function f such that f e1 e2 is zero if the elements e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
Set.SOutput signature of the functor Make.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Stdlib.StackLast-in first-out stacks.
This module implements stacks (LIFOs), with in-place modification.
val create : unit -> 'a tReturn a new stack, initially empty.
val push : 'a -> 'a t -> unitpush x s adds the element x at the top of stack s.
val pop : 'a t -> 'apop s removes and returns the topmost element in stack s, or raises Empty if the stack is empty.
val pop_opt : 'a t -> 'a optionpop_opt s removes and returns the topmost element in stack s, or returns None if the stack is empty.
val top : 'a t -> 'atop s returns the topmost element in stack s, or raises Empty if the stack is empty.
val top_opt : 'a t -> 'a optiontop_opt s returns the topmost element in stack s, or None if the stack is empty.
val clear : 'a t -> unitDiscard all elements from a stack.
val is_empty : 'a t -> boolReturn true if the given stack is empty, false otherwise.
val length : 'a t -> intReturn the number of elements in a stack. Time complexity O(1)
val iter : ('a -> unit) -> 'a t -> unititer f s applies f in turn to all elements of s, from the element at the top of the stack to the element at the bottom of the stack. The stack itself is unchanged.
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'bfold f accu s is (f (... (f (f accu x1) x2) ...) xn) where x1 is the top of the stack, x2 the second element, and xn the bottom element. The stack is unchanged.
Iterate on the stack, top to bottom. It is safe to modify the stack during iteration.
Stdlib.StdLabelsStandard labeled libraries.
This meta-module provides versions of the Array, Bytes, List and String modules where function arguments are systematically labeled. It is intended to be opened at the top of source files, as shown below.
open StdLabels
+
+let to_upper = String.map ~f:Char.uppercase_ascii
+let seq len = List.init ~f:(function i -> i) ~len
+let everything = Array.create_matrix ~dimx:42 ~dimy:42 42module Array = ArrayLabelsmodule Bytes = BytesLabelsmodule List = ListLabelsmodule String = StringLabelsStdlib.StreamStreams and parsers.
Raised by parsers when none of the first components of the stream patterns is accepted.
Raised by parsers when the first component of a stream pattern is accepted, but one of the following components is rejected.
val from : (int -> 'a option) -> 'a tStream.from f returns a stream built from the function f. To create a new stream element, the function f is called with the current stream count. The user function f must return either Some <value> for a value or None to specify the end of the stream.
Do note that the indices passed to f may not start at 0 in the general case. For example, [< '0; '1; Stream.from f >] would call f the first time with count 2.
val of_list : 'a list -> 'a tReturn the stream holding the elements of the list in the same order.
val of_string : string -> char tReturn the stream of the characters of the string parameter.
val of_bytes : bytes -> char tReturn the stream of the characters of the bytes parameter.
val of_channel : in_channel -> char tReturn the stream of the characters read from the input channel.
val iter : ('a -> unit) -> 'a t -> unitStream.iter f s scans the whole stream s, applying function f in turn to each stream element encountered.
val next : 'a t -> 'aReturn the first element of the stream and remove it from the stream.
val empty : 'a t -> unitReturn () if the stream is empty, else raise Stream.Failure.
val peek : 'a t -> 'a optionReturn Some of "the first element" of the stream, or None if the stream is empty.
val junk : 'a t -> unitRemove the first element of the stream, possibly unfreezing it before.
val count : 'a t -> intReturn the current count of the stream elements, i.e. the number of the stream elements discarded.
val npeek : int -> 'a t -> 'a listnpeek n returns the list of the n first elements of the stream, or all its remaining elements if less than n elements are available.
Stdlib.StringStrings.
A string s of length n is an indexable and immutable sequence of n bytes. For historical reasons these bytes are referred to as characters.
The semantics of string functions is defined in terms of indices and positions. These are depicted and described as follows.
positions 0 1 2 3 4 n-1 n + +---+---+---+---+ +-----+ + indices | 0 | 1 | 2 | 3 | ... | n-1 | + +---+---+---+---+ +-----+
i of s is an integer in the range [0;n-1]. It represents the ith byte (character) of s which can be accessed using the constant time string indexing operator s.[i].i of s is an integer in the range [0;n]. It represents either the point at the beginning of the string, or the point between two indices, or the point at the end of the string. The ith byte index is between position i and i+1.Two integers start and len are said to define a valid substring of s if len >= 0 and start, start+len are positions of s.
Unicode text. Strings being arbitrary sequences of bytes, they can hold any kind of textual encoding. However the recommended encoding for storing Unicode text in OCaml strings is UTF-8. This is the encoding used by Unicode escapes in string literals. For example the string "\u{1F42B}" is the UTF-8 encoding of the Unicode character U+1F42B.
Past mutability. OCaml strings used to be modifiable in place, for instance via the String.set and String.blit functions. This use is nowadays only possible when the compiler is put in "unsafe-string" mode by giving the -unsafe-string command-line option. This compatibility mode makes the types string and bytes (see Bytes.t) interchangeable so that functions expecting byte sequences can also accept strings as arguments and modify them.
The distinction between bytes and string was introduced in OCaml 4.02, and the "unsafe-string" compatibility mode was the default until OCaml 4.05. Starting with 4.06, the compatibility mode is opt-in; we intend to remove the option in the future.
The labeled version of this module can be used as described in the StdLabels module.
make n c is a string of length n with each index holding the character c.
init n f is a string of length n with index i holding the character f i (called in increasing index order).
Return a new string that contains the same bytes as the given byte sequence.
Return a new byte sequence that contains the same bytes as the given string.
get s i is the character at index i in s. This is the same as writing s.[i].
Note. The Stdlib.(^) binary operator concatenates two strings.
concat sep ss concatenates the list of strings ss, inserting the separator string sep between each.
compare s0 s1 sorts s0 and s1 in lexicographical order. compare behaves like Stdlib.compare on strings but may be more efficient.
starts_with ~prefix s is true if and only if s starts with prefix.
ends_with ~suffix s is true if and only if s ends with suffix.
contains_from s start c is true if and only if c appears in s after position start.
rcontains_from s stop c is true if and only if c appears in s before position stop+1.
contains s c is String.contains_from s 0 c.
sub s pos len is a string of length len, containing the substring of s that starts at position pos and has length len.
split_on_char sep s is the list of all (possibly empty) substrings of s that are delimited by the character sep.
The function's result is specified by the following invariants:
sep as a separator returns a string equal to the input (concat (make 1 sep)
+ (split_on_char sep s) = s).sep character.map f s is the string resulting from applying f to all the characters of s in increasing order.
mapi f s is like map but the index of the character is also passed to f.
fold_left f x s computes f (... (f (f x s.[0]) s.[1]) ...) s.[n-1], where n is the length of the string s.
fold_right f s x computes f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)), where n is the length of the string s.
for_all p s checks if all characters in s satisfy the predicate p.
exists p s checks if at least one character of s satisfies the predicate p.
trim s is s without leading and trailing whitespace. Whitespace characters are: ' ', '\x0C' (form feed), '\n', '\r', and '\t'.
escaped s is s with special characters represented by escape sequences, following the lexical conventions of OCaml.
All characters outside the US-ASCII printable range [0x20;0x7E] are escaped, as well as backslash (0x2F) and double-quote (0x22).
The function Scanf.unescaped is a left inverse of escaped, i.e. Scanf.unescaped (escaped s) = s for any string s (unless escaped s fails).
uppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.
lowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.
capitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.
uncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.
iter f s applies function f in turn to all the characters of s. It is equivalent to f s.[0]; f s.[1]; ...; f s.[length s - 1]; ().
iteri is like iter, but the function is also given the corresponding character index.
index_from s i c is the index of the first occurrence of c in s after position i.
index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).
rindex_from s i c is the index of the last occurrence of c in s before position i+1.
rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).
index s c is String.index_from s 0 c.
index_opt s c is String.index_from_opt s 0 c.
rindex s c is String.rindex_from s (length s - 1) c.
rindex_opt s c is String.rindex_from_opt s (length s - 1) c.
to_seq s is a sequence made of the string's characters in increasing order. In "unsafe-string" mode, modifications of the string during iteration will be reflected in the sequence.
to_seqi s is like to_seq but also tuples the corresponding index.
val get_utf_8_uchar : t -> int -> Uchar.utf_decodeget_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val is_valid_utf_8 : t -> boolis_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
val get_utf_16be_uchar : t -> int -> Uchar.utf_decodeget_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val is_valid_utf_16be : t -> boolis_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
val get_utf_16le_uchar : t -> int -> Uchar.utf_decodeget_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val is_valid_utf_16le : t -> boolis_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
create n returns a fresh byte sequence of length n. The sequence is uninitialized and contains arbitrary bytes.
set s n c modifies byte sequence s in place, replacing the byte at index n with c. You can also write s.[n] <- c instead of set s n c.
blit src src_pos dst dst_pos len copies len bytes from the string src, starting at index src_pos, to byte sequence dst, starting at character number dst_pos.
fill s pos len c modifies byte sequence s in place, replacing len bytes by c, starting at pos.
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..
Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
The functions in this section binary decode integers from strings.
All following functions raise Invalid_argument if the characters needed at index i to decode the integer are not available.
Little-endian (resp. big-endian) encoding means that least (resp. most) significant bytes are stored first. Big-endian is also known as network byte order. Native-endian encoding is either little-endian or big-endian depending on Sys.big_endian.
32-bit and 64-bit integers are represented by the int32 and int64 types, which can be interpreted either as signed or unsigned numbers.
8-bit and 16-bit integers are represented by the int type, which has more bits than the binary encoding. These extra bits are sign-extended (or zero-extended) for functions which decode 8-bit or 16-bit integers and represented them with int values.
get_uint8 b i is b's unsigned 8-bit integer starting at character index i.
get_int8 b i is b's signed 8-bit integer starting at character index i.
get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.
get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.
get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.
get_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.
get_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.
get_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.
get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.
get_int32_be b i is b's big-endian 32-bit integer starting at character index i.
get_int32_le b i is b's little-endian 32-bit integer starting at character index i.
get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.
get_int64_be b i is b's big-endian 64-bit integer starting at character index i.
Stdlib.StringLabelsStrings.
A string s of length n is an indexable and immutable sequence of n bytes. For historical reasons these bytes are referred to as characters.
The semantics of string functions is defined in terms of indices and positions. These are depicted and described as follows.
positions 0 1 2 3 4 n-1 n + +---+---+---+---+ +-----+ + indices | 0 | 1 | 2 | 3 | ... | n-1 | + +---+---+---+---+ +-----+
i of s is an integer in the range [0;n-1]. It represents the ith byte (character) of s which can be accessed using the constant time string indexing operator s.[i].i of s is an integer in the range [0;n]. It represents either the point at the beginning of the string, or the point between two indices, or the point at the end of the string. The ith byte index is between position i and i+1.Two integers start and len are said to define a valid substring of s if len >= 0 and start, start+len are positions of s.
Unicode text. Strings being arbitrary sequences of bytes, they can hold any kind of textual encoding. However the recommended encoding for storing Unicode text in OCaml strings is UTF-8. This is the encoding used by Unicode escapes in string literals. For example the string "\u{1F42B}" is the UTF-8 encoding of the Unicode character U+1F42B.
Past mutability. OCaml strings used to be modifiable in place, for instance via the String.set and String.blit functions. This use is nowadays only possible when the compiler is put in "unsafe-string" mode by giving the -unsafe-string command-line option. This compatibility mode makes the types string and bytes (see Bytes.t) interchangeable so that functions expecting byte sequences can also accept strings as arguments and modify them.
The distinction between bytes and string was introduced in OCaml 4.02, and the "unsafe-string" compatibility mode was the default until OCaml 4.05. Starting with 4.06, the compatibility mode is opt-in; we intend to remove the option in the future.
The labeled version of this module can be used as described in the StdLabels module.
make n c is a string of length n with each index holding the character c.
init n ~f is a string of length n with index i holding the character f i (called in increasing index order).
Return a new string that contains the same bytes as the given byte sequence.
Return a new byte sequence that contains the same bytes as the given string.
get s i is the character at index i in s. This is the same as writing s.[i].
Note. The Stdlib.(^) binary operator concatenates two strings.
concat ~sep ss concatenates the list of strings ss, inserting the separator string sep between each.
compare s0 s1 sorts s0 and s1 in lexicographical order. compare behaves like Stdlib.compare on strings but may be more efficient.
starts_with ~prefix s is true if and only if s starts with prefix.
ends_with ~suffix s is true if and only if s ends with suffix.
contains_from s start c is true if and only if c appears in s after position start.
rcontains_from s stop c is true if and only if c appears in s before position stop+1.
contains s c is String.contains_from s 0 c.
sub s ~pos ~len is a string of length len, containing the substring of s that starts at position pos and has length len.
split_on_char ~sep s is the list of all (possibly empty) substrings of s that are delimited by the character sep.
The function's result is specified by the following invariants:
sep as a separator returns a string equal to the input (concat (make 1 sep)
+ (split_on_char sep s) = s).sep character.map f s is the string resulting from applying f to all the characters of s in increasing order.
mapi ~f s is like map but the index of the character is also passed to f.
fold_left f x s computes f (... (f (f x s.[0]) s.[1]) ...) s.[n-1], where n is the length of the string s.
fold_right f s x computes f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)), where n is the length of the string s.
for_all p s checks if all characters in s satisfy the predicate p.
exists p s checks if at least one character of s satisfies the predicate p.
trim s is s without leading and trailing whitespace. Whitespace characters are: ' ', '\x0C' (form feed), '\n', '\r', and '\t'.
escaped s is s with special characters represented by escape sequences, following the lexical conventions of OCaml.
All characters outside the US-ASCII printable range [0x20;0x7E] are escaped, as well as backslash (0x2F) and double-quote (0x22).
The function Scanf.unescaped is a left inverse of escaped, i.e. Scanf.unescaped (escaped s) = s for any string s (unless escaped s fails).
uppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.
lowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.
capitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.
uncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.
iter ~f s applies function f in turn to all the characters of s. It is equivalent to f s.[0]; f s.[1]; ...; f s.[length s - 1]; ().
iteri is like iter, but the function is also given the corresponding character index.
index_from s i c is the index of the first occurrence of c in s after position i.
index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).
rindex_from s i c is the index of the last occurrence of c in s before position i+1.
rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).
index s c is String.index_from s 0 c.
index_opt s c is String.index_from_opt s 0 c.
rindex s c is String.rindex_from s (length s - 1) c.
rindex_opt s c is String.rindex_from_opt s (length s - 1) c.
to_seq s is a sequence made of the string's characters in increasing order. In "unsafe-string" mode, modifications of the string during iteration will be reflected in the sequence.
to_seqi s is like to_seq but also tuples the corresponding index.
val get_utf_8_uchar : t -> int -> Uchar.utf_decodeget_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val is_valid_utf_8 : t -> boolis_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
val get_utf_16be_uchar : t -> int -> Uchar.utf_decodeget_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val is_valid_utf_16be : t -> boolis_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
val get_utf_16le_uchar : t -> int -> Uchar.utf_decodeget_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val is_valid_utf_16le : t -> boolis_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
create n returns a fresh byte sequence of length n. The sequence is uninitialized and contains arbitrary bytes.
set s n c modifies byte sequence s in place, replacing the byte at index n with c. You can also write s.[n] <- c instead of set s n c.
blit ~src ~src_pos ~dst ~dst_pos ~len copies len bytes from the string src, starting at index src_pos, to byte sequence dst, starting at character number dst_pos.
fill s ~pos ~len c modifies byte sequence s in place, replacing len bytes by c, starting at pos.
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..
Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
The functions in this section binary decode integers from strings.
All following functions raise Invalid_argument if the characters needed at index i to decode the integer are not available.
Little-endian (resp. big-endian) encoding means that least (resp. most) significant bytes are stored first. Big-endian is also known as network byte order. Native-endian encoding is either little-endian or big-endian depending on Sys.big_endian.
32-bit and 64-bit integers are represented by the int32 and int64 types, which can be interpreted either as signed or unsigned numbers.
8-bit and 16-bit integers are represented by the int type, which has more bits than the binary encoding. These extra bits are sign-extended (or zero-extended) for functions which decode 8-bit or 16-bit integers and represented them with int values.
get_uint8 b i is b's unsigned 8-bit integer starting at character index i.
get_int8 b i is b's signed 8-bit integer starting at character index i.
get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.
get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.
get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.
get_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.
get_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.
get_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.
get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.
get_int32_be b i is b's big-endian 32-bit integer starting at character index i.
get_int32_le b i is b's little-endian 32-bit integer starting at character index i.
get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.
get_int64_be b i is b's big-endian 64-bit integer starting at character index i.
Make.ImmediateMake.Non_immediateImmediate64.MakeSys.Immediate64This module allows to define a type t with the immediate64 attribute. This attribute means that the type is immediate on 64 bit architectures. On other architectures, it might or might not be immediate.
module type Non_immediate = sig ... endmodule type Immediate = sig ... endmodule Make
+ (Immediate : Immediate)
+ (Non_immediate : Non_immediate) :
+ sig ... endImmediate64.ImmediateImmediate64.Non_immediateStdlib.SysSystem interface.
Every function in this module raises Sys_error with an informative message when the underlying system call signal an error.
The command line arguments given to the process. The first element is the command name used to invoke the program. The following elements are the command-line arguments given to the program.
The name of the file containing the executable currently running. This name may be absolute or relative to the current directory, depending on the platform and whether the program was compiled to bytecode or a native executable.
Returns true if the given name refers to a directory, false if it refers to another kind of file.
Rename a file. rename oldpath newpath renames the file called oldpath, giving it newpath as its new name, moving it between directories if needed. If newpath already exists, its contents will be replaced with those of oldpath. Depending on the operating system, the metadata (permissions, owner, etc) of newpath can either be preserved or be replaced by those of oldpath.
Return the value associated to a variable in the process environment or None if the variable is unbound.
Execute the given shell command and return its exit code.
The argument of Sys.command is generally the name of a command followed by zero, one or several arguments, separated by whitespace. The given argument is interpreted by a shell: either the Windows shell cmd.exe for the Win32 ports of OCaml, or the POSIX shell sh for other ports. It can contain shell builtin commands such as echo, and also special characters such as file redirections > and <, which will be honored by the shell.
Conversely, whitespace or special shell characters occurring in command names or in their arguments must be quoted or escaped so that the shell does not interpret them. The quoting rules vary between the POSIX shell and the Windows shell. The Filename.quote_command performs the appropriate quoting given a command name, a list of arguments, and optional file redirections.
Return the processor time, in seconds, used by the program since the beginning of execution.
Return the names of all files present in the given directory. Names denoting the current directory and the parent directory ("." and ".." in Unix) are not returned. Each string in the result is a file name rather than a complete path. There is no guarantee that the name strings in the resulting array will appear in any specific order; they are not, in particular, guaranteed to appear in alphabetical order.
val interactive : bool refThis reference is initially set to false in standalone programs and to true if the code is being executed under the interactive toplevel system ocaml.
Operating system currently executing the OCaml program. One of
"Unix" (for all Unix versions, including Linux and Mac OS X),"Win32" (for MS-Windows, OCaml compiled with MSVC++ or Mingw),"Cygwin" (for MS-Windows, OCaml compiled with Cygwin).Currently, the official distribution only supports Native and Bytecode, but it can be other backends with alternative compilers, for example, javascript.
val backend_type : backend_typeBackend type currently executing the OCaml program.
Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64.
Size of int, in bits. It is 31 (resp. 63) when using OCaml on a 32-bit (resp. 64-bit) platform. It may differ for other implementations, e.g. it can be 32 bits when compiling to JavaScript.
Maximum length of a normal array (i.e. any array whose elements are not of type float). The maximum length of a float array is max_floatarray_length if OCaml was configured with --enable-flat-float-array and max_array_length if configured with --disable-flat-float-array.
Maximum length of a floatarray. This is also the maximum length of a float array when OCaml is configured with --enable-flat-float-array.
Return the name of the runtime variant the program is running on. This is normally the argument given to -runtime-variant at compile time, but for byte-code it can be changed after compilation.
Return the value of the runtime parameters, in the same format as the contents of the OCAMLRUNPARAM environment variable.
What to do when receiving a signal:
Signal_default: take the default behavior (usually: abort the program)Signal_ignore: ignore the signalSignal_handle f: call function f, giving it the signal number as argument.val signal : int -> signal_behavior -> signal_behaviorSet the behavior of the system on receipt of a given signal. The first argument is the signal number. Return the behavior previously associated with the signal. If the signal number is invalid (or not available on your system), an Invalid_argument exception is raised.
val set_signal : int -> signal_behavior -> unitSame as Sys.signal but return value is ignored.
Exception raised on interactive interrupt if Sys.catch_break is on.
catch_break governs whether interactive interrupt (ctrl-C) terminates the program or raises the Break exception. Call catch_break true to enable raising Break, and catch_break false to let the system terminate the program on user interrupt.
ocaml_version is the version of OCaml. It is a string of the form "major.minor[.patchlevel][(+|~)additional-info]", where major, minor, and patchlevel are integers, and additional-info is an arbitrary string. The [.patchlevel] part was absent before version 3.08.0 and became mandatory from 3.08.0 onwards. The [(+|~)additional-info] part may be absent.
type extra_info = extra_prefix * stringval ocaml_release : ocaml_release_infoControl whether the OCaml runtime system can emit warnings on stderr. Currently, the only supported warning is triggered when a channel created by open_* functions is finalized without being closed. Runtime warnings are disabled by default.
For the purposes of optimization, opaque_identity behaves like an unknown (and thus possibly side-effecting) function.
At runtime, opaque_identity disappears altogether.
A typical use of this function is to prevent pure computations from being optimized away in benchmarking loops. For example:
for _round = 1 to 100_000 do
+ ignore (Sys.opaque_identity (my_pure_computation ()))
+donemodule Immediate64 : sig ... endThis module allows to define a type t with the immediate64 attribute. This attribute means that the type is immediate on 64 bit architectures. On other architectures, it might or might not be immediate.
Stdlib.UcharUnicode characters.
The type for Unicode characters.
A value of this type represents a Unicode scalar value which is an integer in the ranges 0x0000...0xD7FF or 0xE000...0x10FFFF.
val min : tmin is U+0000.
val max : tmax is U+10FFFF.
val bom : tbom is U+FEFF, the byte order mark (BOM) character.
val rep : trep is U+FFFD, the replacement character.
is_valid n is true if and only if n is a Unicode scalar value (i.e. in the ranges 0x0000...0xD7FF or 0xE000...0x10FFFF).
val of_int : int -> tof_int i is i as a Unicode character.
val to_int : t -> intto_int u is u as an integer.
val is_char : t -> boolis_char u is true if and only if u is a latin1 OCaml character.
val of_char : char -> tof_char c is c as a Unicode character.
val to_char : t -> charto_char u is u as an OCaml latin1 character.
val hash : t -> inthash u associates a non-negative integer to u.
The type for UTF decode results. Values of this type represent the result of a Unicode Transformation Format decoding attempt.
val utf_decode_is_valid : utf_decode -> boolutf_decode_is_valid d is true if and only if d holds a valid decode.
val utf_decode_uchar : utf_decode -> tutf_decode_uchar d is the Unicode character decoded by d if utf_decode_is_valid d is true and Uchar.rep otherwise.
val utf_decode_length : utf_decode -> intutf_decode_length d is the number of elements from the source that were consumed by the decode d. This is always strictly positive and smaller or equal to 4. The kind of source elements depends on the actual decoder; for the decoders of the standard library this function always returns a length in bytes.
val utf_decode : int -> t -> utf_decodeutf_decode n u is a valid UTF decode for u that consumed n elements from the source for decoding. n must be positive and smaller or equal to 4 (this is not checked by the module).
val utf_decode_invalid : int -> utf_decodeutf_decode_invalid n is an invalid UTF decode that consumed n elements from the source to error. n must be positive and smaller or equal to 4 (this is not checked by the module). The resulting decode has rep as the decoded Unicode character.
val utf_8_byte_length : t -> intutf_8_byte_length u is the number of bytes needed to encode u in UTF-8.
val utf_16_byte_length : t -> intutf_16_byte_length u is the number of bytes needed to encode u in UTF-16.
Stdlib.UnitUnit values.
The unit type.
The constructor () is included here so that it has a path, but it is not intended to be used in user-defined data types.
val to_string : t -> stringto_string b is "()".
Make.Hval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).Weak.MakeFunctor building an implementation of the weak hash set structure. H.equal can't be the physical equality, since only shallow copies of the elements in the set are given to it.
module H : Hashtbl.HashedTypetype data = H.tThe type of the elements stored in the table.
The type of tables that contain elements of type data. Note that weak hash sets cannot be marshaled using Stdlib.output_value or the functions of the Marshal module.
val create : int -> tcreate n creates a new empty weak hash set, of initial size n. The table will grow as needed.
val clear : t -> unitRemove all elements from the table.
merge t x returns an instance of x found in t if any, or else adds x to t and return x.
add t x adds x to t. If there is already an instance of x in t, it is unspecified which one will be returned by subsequent calls to find and merge.
remove t x removes from t one instance of x. Does nothing if there is no instance of x in t.
find_opt t x returns an instance of x found in t or None if there is no such element.
find_all t x returns a list of all the instances of x found in t.
mem t x returns true if there is at least one instance of x in t, false otherwise.
iter f t calls f on each element of t, in some unspecified order. It is not specified what happens if f tries to change t itself.
fold f t init computes (f d1 (... (f dN init))) where d1 ... dN are the elements of t in some unspecified order. It is not specified what happens if f tries to change t itself.
val count : t -> intCount the number of elements in the table. count t gives the same result as fold (fun _ n -> n+1) t 0 but does not delay the deallocation of the dead elements.
val stats : t -> int * int * int * int * int * intReturn statistics on the table. The numbers are, in order: table length, number of entries, sum of bucket lengths, smallest bucket length, median bucket length, biggest bucket length.
Stdlib.WeakArrays of weak pointers and hash sets of weak pointers.
The type of arrays of weak pointers (weak arrays). A weak pointer is a value that the garbage collector may erase whenever the value is not used any more (through normal pointers) by the program. Note that finalisation functions are run before the weak pointers are erased, because the finalisation functions can make values alive again (before 4.03 the finalisation functions were run after).
A weak pointer is said to be full if it points to a value, empty if the value was erased by the GC.
Notes:
Stdlib.output_value nor the functions of the Marshal module.val create : int -> 'a tWeak.create n returns a new weak array of length n. All the pointers are initially empty.
val length : 'a t -> intWeak.length ar returns the length (number of elements) of ar.
val set : 'a t -> int -> 'a option -> unitWeak.set ar n (Some el) sets the nth cell of ar to be a (full) pointer to el; Weak.set ar n None sets the nth cell of ar to empty.
val get : 'a t -> int -> 'a optionWeak.get ar n returns None if the nth cell of ar is empty, Some x (where x is the value) if it is full.
val get_copy : 'a t -> int -> 'a optionWeak.get_copy ar n returns None if the nth cell of ar is empty, Some x (where x is a (shallow) copy of the value) if it is full. In addition to pitfalls with mutable values, the interesting difference with get is that get_copy does not prevent the incremental GC from erasing the value in its current cycle (get may delay the erasure to the next GC cycle).
val check : 'a t -> int -> boolWeak.check ar n returns true if the nth cell of ar is full, false if it is empty. Note that even if Weak.check ar n returns true, a subsequent Weak.get ar n can return None.
val fill : 'a t -> int -> int -> 'a option -> unitWeak.fill ar ofs len el sets to el all pointers of ar from ofs to ofs + len - 1.
Weak.blit ar1 off1 ar2 off2 len copies len weak pointers from ar1 (starting at off1) to ar2 (starting at off2). It works correctly even if ar1 and ar2 are the same.
A weak hash set is a hashed set of values. Each value may magically disappear from the set when it is not used by the rest of the program any more. This is normally used to share data structures without inducing memory leaks. Weak hash sets are defined on values from a Hashtbl.HashedType module; the equal relation and hash function are taken from that module. We will say that v is an instance of x if equal x v is true.
The equal relation must be able to work on a shallow copy of the values and give the same result as with the values themselves.
Weak.SThe output signature of the functor Weak.Make.
The type of tables that contain elements of type data. Note that weak hash sets cannot be marshaled using Stdlib.output_value or the functions of the Marshal module.
val create : int -> tcreate n creates a new empty weak hash set, of initial size n. The table will grow as needed.
val clear : t -> unitRemove all elements from the table.
merge t x returns an instance of x found in t if any, or else adds x to t and return x.
add t x adds x to t. If there is already an instance of x in t, it is unspecified which one will be returned by subsequent calls to find and merge.
remove t x removes from t one instance of x. Does nothing if there is no instance of x in t.
find_opt t x returns an instance of x found in t or None if there is no such element.
find_all t x returns a list of all the instances of x found in t.
mem t x returns true if there is at least one instance of x in t, false otherwise.
iter f t calls f on each element of t, in some unspecified order. It is not specified what happens if f tries to change t itself.
fold f t init computes (f d1 (... (f dN init))) where d1 ... dN are the elements of t in some unspecified order. It is not specified what happens if f tries to change t itself.
val count : t -> intCount the number of elements in the table. count t gives the same result as fold (fun _ n -> n+1) t 0 but does not delay the deallocation of the dead elements.
val stats : t -> int * int * int * int * int * intReturn statistics on the table. The numbers are, in order: table length, number of entries, sum of bucket lengths, smallest bucket length, median bucket length, biggest bucket length.
StdlibThe OCaml Standard library.
This module is automatically opened at the beginning of each compilation. All components of this module can therefore be referred by their short name, without prefixing them by Stdlib.
It particular, it provides the basic operations over the built-in types (numbers, booleans, byte sequences, strings, exceptions, references, lists, arrays, input-output channels, ...) and the standard library modules.
The Exit exception is not raised by any library function. It is provided for use in your programs.
Exception raised when none of the cases of a pattern-matching apply. The arguments are the location of the match keyword in the source code (file name, line number, column number).
Exception raised when an assertion fails. The arguments are the location of the assert keyword in the source code (file name, line number, column number).
Exception raised by library functions to signal that the given arguments do not make sense. The string gives some information to the programmer. As a general rule, this exception should not be caught, it denotes a programming error and the code should be modified not to trigger it.
Exception raised by library functions to signal that they are undefined on the given arguments. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Failure _ instead).
Exception raised by the garbage collector when there is insufficient memory to complete the computation. (Not reliable for allocations on the minor heap.)
Exception raised by the bytecode interpreter when the evaluation stack reaches its maximal size. This often indicates infinite or excessively deep recursion in the user's program.
Before 4.10, it was not fully implemented by the native-code compiler.
Exception raised by the input/output functions to report an operating system error. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Sys_error _ instead).
Exception raised by input functions to signal that the end of file has been reached.
Exception raised by integer division and remainder operations when their second argument is zero.
A special case of Sys_error raised when no I/O is possible on a non-blocking I/O channel.
Exception raised when an ill-founded recursive module definition is evaluated. The arguments are the location of the definition in the source code (file name, line number, column number).
e1 = e2 tests for structural equality of e1 and e2. Mutable structures (e.g. references and arrays) are equal if and only if their current contents are structurally equal, even if the two mutable objects are not the same physical object. Equality between functional values raises Invalid_argument. Equality between cyclic data structures may not terminate. Left-associative operator, see Ocaml_operators for more information.
Negation of Stdlib.(=). Left-associative operator, see Ocaml_operators for more information.
See Stdlib.(>=). Left-associative operator, see Ocaml_operators for more information.
See Stdlib.(>=). Left-associative operator, see Ocaml_operators for more information.
See Stdlib.(>=). Left-associative operator, see Ocaml_operators for more information.
Structural ordering functions. These functions coincide with the usual orderings over integers, characters, strings, byte sequences and floating-point numbers, and extend them to a total ordering over all types. The ordering is compatible with ( = ). As in the case of ( = ), mutable structures are compared by contents. Comparison between functional values raises Invalid_argument. Comparison between cyclic structures may not terminate. Left-associative operator, see Ocaml_operators for more information.
compare x y returns 0 if x is equal to y, a negative integer if x is less than y, and a positive integer if x is greater than y. The ordering implemented by compare is compatible with the comparison predicates =, < and > defined above, with one difference on the treatment of the float value Stdlib.nan. Namely, the comparison predicates treat nan as different from any other float value, including itself; while compare treats nan as equal to itself and less than any other float value. This treatment of nan ensures that compare defines a total ordering relation.
compare applied to functional values may raise Invalid_argument. compare applied to cyclic structures may not terminate.
The compare function can be used as the comparison function required by the Set.Make and Map.Make functors, as well as the List.sort and Array.sort functions.
Return the smaller of the two arguments. The result is unspecified if one of the arguments contains the float value nan.
Return the greater of the two arguments. The result is unspecified if one of the arguments contains the float value nan.
e1 == e2 tests for physical equality of e1 and e2. On mutable types such as references, arrays, byte sequences, records with mutable fields and objects with mutable instance variables, e1 == e2 is true if and only if physical modification of e1 also affects e2. On non-mutable types, the behavior of ( == ) is implementation-dependent; however, it is guaranteed that e1 == e2 implies compare e1 e2 = 0. Left-associative operator, see Ocaml_operators for more information.
Negation of Stdlib.(==). Left-associative operator, see Ocaml_operators for more information.
The boolean 'and'. Evaluation is sequential, left-to-right: in e1 && e2, e1 is evaluated first, and if it returns false, e2 is not evaluated at all. Right-associative operator, see Ocaml_operators for more information.
The boolean 'or'. Evaluation is sequential, left-to-right: in e1 || e2, e1 is evaluated first, and if it returns true, e2 is not evaluated at all. Right-associative operator, see Ocaml_operators for more information.
__LOC__ returns the location at which this expression appears in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LINE__ returns the line number at which this expression appears in the file currently being parsed by the compiler.
__POS__ returns a tuple (file,lnum,cnum,enum), corresponding to the location at which this expression appears in the file currently being parsed by the compiler. file is the current filename, lnum the line number, cnum the character position in the line and enum the last character position in the line.
__FUNCTION__ returns the name of the current function or method, including any enclosing modules or classes.
__LOC_OF__ expr returns a pair (loc, expr) where loc is the location of expr in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LINE_OF__ expr returns a pair (line, expr), where line is the line number at which the expression expr appears in the file currently being parsed by the compiler.
__POS_OF__ expr returns a pair (loc,expr), where loc is a tuple (file,lnum,cnum,enum) corresponding to the location at which the expression expr appears in the file currently being parsed by the compiler. file is the current filename, lnum the line number, cnum the character position in the line and enum the last character position in the line.
Reverse-application operator: x |> f |> g is exactly equivalent to g (f (x)). Left-associative operator, see Ocaml_operators for more information.
Application operator: g @@ f @@ x is exactly equivalent to g (f (x)). Right-associative operator, see Ocaml_operators for more information.
Integers are Sys.int_size bits wide. All operations are taken modulo 2Sys.int_size. They do not fail on overflow.
Unary negation. You can also write - e instead of ~- e. Unary operator, see Ocaml_operators for more information.
Unary addition. You can also write + e instead of ~+ e. Unary operator, see Ocaml_operators for more information.
Integer addition. Left-associative operator, see Ocaml_operators for more information.
Integer subtraction. Left-associative operator, , see Ocaml_operators for more information.
Integer multiplication. Left-associative operator, see Ocaml_operators for more information.
Integer division. Integer division rounds the real quotient of its arguments towards zero. More precisely, if x >= 0 and y > 0, x / y is the greatest integer less than or equal to the real quotient of x by y. Moreover, (- x) / y = x / (- y) = - (x / y). Left-associative operator, see Ocaml_operators for more information.
Integer remainder. If y is not zero, the result of x mod y satisfies the following properties: x = (x / y) * y + x mod y and abs(x mod y) <= abs(y) - 1. If y = 0, x mod y raises Division_by_zero. Note that x mod y is negative only if x < 0. Left-associative operator, see Ocaml_operators for more information.
Return the absolute value of the argument. Note that this may be negative if the argument is min_int.
Bitwise logical and. Left-associative operator, see Ocaml_operators for more information.
Bitwise logical or. Left-associative operator, see Ocaml_operators for more information.
Bitwise logical exclusive or. Left-associative operator, see Ocaml_operators for more information.
n lsl m shifts n to the left by m bits. The result is unspecified if m < 0 or m > Sys.int_size. Right-associative operator, see Ocaml_operators for more information.
n lsr m shifts n to the right by m bits. This is a logical shift: zeroes are inserted regardless of the sign of n. The result is unspecified if m < 0 or m > Sys.int_size. Right-associative operator, see Ocaml_operators for more information.
n asr m shifts n to the right by m bits. This is an arithmetic shift: the sign bit of n is replicated. The result is unspecified if m < 0 or m > Sys.int_size. Right-associative operator, see Ocaml_operators for more information.
OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-point operations never raise an exception on overflow, underflow, division by zero, etc. Instead, special IEEE numbers are returned as appropriate, such as infinity for 1.0 /. 0.0, neg_infinity for -1.0 /. 0.0, and nan ('not a number') for 0.0 /. 0.0. These special numbers then propagate through floating-point computations as expected: for instance, 1.0 /. infinity is 0.0, basic arithmetic operations (+., -., *., /.) with nan as an argument return nan, ...
Unary negation. You can also write -. e instead of ~-. e. Unary operator, see Ocaml_operators for more information.
Unary addition. You can also write +. e instead of ~+. e. Unary operator, see Ocaml_operators for more information.
Floating-point addition. Left-associative operator, see Ocaml_operators for more information.
Floating-point subtraction. Left-associative operator, see Ocaml_operators for more information.
Floating-point multiplication. Left-associative operator, see Ocaml_operators for more information.
Floating-point division. Left-associative operator, see Ocaml_operators for more information.
Exponentiation. Right-associative operator, see Ocaml_operators for more information.
expm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.
log1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.
Arc cosine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between 0.0 and pi.
Arc sine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between -pi/2 and pi/2.
atan2 y x returns the arc tangent of y /. x. The signs of x and y are used to determine the quadrant of the result. Result is in radians and is between -pi and pi.
hypot x y returns sqrt(x *. x + y *. y), that is, the length of the hypotenuse of a right-angled triangle with sides of length x and y, or, equivalently, the distance of the point (x,y) to origin. If one of x or y is infinite, returns infinity even if the other is nan.
Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]. Result is in radians and is between 0.0 and inf.
Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]. Result is in radians and ranges over the entire real line.
Round above to an integer value. ceil f returns the least integer value greater than or equal to f. The result is returned as a float.
Round below to an integer value. floor f returns the greatest integer value less than or equal to f. The result is returned as a float.
copysign x y returns a float whose absolute value is that of x and whose sign is that of y. If x is nan, returns nan. If y is nan, returns either x or -. x, but it is not specified which.
mod_float a b returns the remainder of a with respect to b. The returned value is a -. n *. b, where n is the quotient a /. b rounded towards zero to an integer.
frexp f returns the pair of the significant and the exponent of f. When f is zero, the significant x and the exponent n of f are equal to zero. When f is non-zero, they are defined by f = x *. 2 ** n and 0.5 <= x < 1.0.
Same as Stdlib.float_of_int.
Same as Stdlib.int_of_float.
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan or falls outside the range of representable integers.
A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0. Stands for 'not a number'. Any floating-point operation with nan as argument returns nan as result. As for floating-point comparisons, =, <, <=, > and >= return false and <> returns true if one or both of their arguments is nan.
The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0.
The five classes of floating-point numbers, as determined by the Stdlib.classify_float function.
val classify_float : float -> fpclassReturn the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
More string operations are provided in module String.
String concatenation. Right-associative operator, see Ocaml_operators for more information.
More character operations are provided in module Char.
Discard the value of its argument and return (). For instance, ignore(f x) discards the result of the side-effecting function f. It is equivalent to f x; (), except that the latter may generate a compiler warning; writing ignore(f x) instead avoids the warning.
Return the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
Convert the given string to a boolean.
Return None if the string is not "true" or "false".
Same as Stdlib.bool_of_string_opt, but raise Invalid_argument "bool_of_string" instead of returning None.
Convert the given string to an integer. The string is read in decimal (by default, or if the string begins with 0u), in hexadecimal (if it begins with 0x or 0X), in octal (if it begins with 0o or 0O), or in binary (if it begins with 0b or 0B).
The 0u prefix reads the input as an unsigned integer in the range [0, 2*max_int+1]. If the input exceeds max_int it is converted to the signed integer min_int + input - max_int - 1.
The _ (underscore) character can appear anywhere in the string and is ignored.
Return None if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int.
Same as Stdlib.int_of_string_opt, but raise Failure "int_of_string" instead of returning None.
Return a string representation of a floating-point number.
This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see Printf.
Convert the given string to a float. The string is read in decimal (by default) or in hexadecimal (marked by 0x or 0X).
The format of decimal floating-point numbers is [-] dd.ddd (e|E) [+|-] dd , where d stands for a decimal digit.
The format of hexadecimal floating-point numbers is [-] 0(x|X) hh.hhh (p|P) [+|-] dd , where h stands for an hexadecimal digit and d for a decimal digit.
In both cases, at least one of the integer and fractional parts must be given; the exponent part is optional.
The _ (underscore) character can appear anywhere in the string and is ignored.
Depending on the execution platforms, other representations of floating-point numbers can be accepted, but should not be relied upon.
Return None if the given string is not a valid representation of a float.
Same as Stdlib.float_of_string_opt, but raise Failure "float_of_string" instead of returning None.
More list operations are provided in module List.
List concatenation. Not tail-recursive (length of the first argument). Right-associative operator, see Ocaml_operators for more information.
Note: all input/output functions can raise Sys_error when the system calls they invoke fail.
val stdin : in_channelThe standard input for the process.
val stdout : out_channelThe standard output for the process.
val stderr : out_channelThe standard error output for the process.
Print a floating-point number, in decimal, on standard output.
The conversion of the number to a string uses string_of_float and can involve a loss of precision.
Print a string, followed by a newline character, on standard output and flush standard output.
Print a newline character on standard output, and flush standard output. This can be used to simulate line buffering of standard output.
Print a floating-point number, in decimal, on standard error.
The conversion of the number to a string uses string_of_float and can involve a loss of precision.
Print a string, followed by a newline character on standard error and flush standard error.
Print a newline character on standard error, and flush standard error.
Flush standard output, then read characters from standard input until a newline character is encountered.
Return the string of all characters read, without the newline character at the end.
Flush standard output, then read one line from standard input and convert it to an integer.
Return None if the line read is not a valid representation of an integer.
Same as Stdlib.read_int_opt, but raise Failure "int_of_string" instead of returning None.
Flush standard output, then read one line from standard input and convert it to a floating-point number.
Return None if the line read is not a valid representation of a floating-point number.
Same as Stdlib.read_float_opt, but raise Failure "float_of_string" instead of returning None.
type open_flag = | Open_rdonlyopen for reading.
*)| Open_wronlyopen for writing.
*)| Open_appendopen for appending: always write at end of file.
*)| Open_creatcreate the file if it does not exist.
*)| Open_truncempty the file if it already exists.
*)| Open_exclfail if Open_creat and the file already exists.
*)| Open_binaryopen in binary mode (no conversion).
*)| Open_textopen in text mode (may perform conversions).
*)| Open_nonblockopen in non-blocking mode.
*)Opening modes for Stdlib.open_out_gen and Stdlib.open_in_gen.
val open_out : string -> out_channelOpen the named file for writing, and return a new output channel on that file, positioned at the beginning of the file. The file is truncated to zero length if it already exists. It is created if it does not already exists.
val open_out_bin : string -> out_channelSame as Stdlib.open_out, but the file is opened in binary mode, so that no translation takes place during writes. On operating systems that do not distinguish between text mode and binary mode, this function behaves like Stdlib.open_out.
val open_out_gen : open_flag list -> int -> string -> out_channelopen_out_gen mode perm filename opens the named file for writing, as described above. The extra argument mode specifies the opening mode. The extra argument perm specifies the file permissions, in case the file must be created. Stdlib.open_out and Stdlib.open_out_bin are special cases of this function.
val flush : out_channel -> unitFlush the buffer associated with the given output channel, performing all pending writes on that channel. Interactive programs must be careful about flushing standard output and standard error at the right time.
val output_char : out_channel -> char -> unitWrite the character on the given output channel.
val output_string : out_channel -> string -> unitWrite the string on the given output channel.
val output_bytes : out_channel -> bytes -> unitWrite the byte sequence on the given output channel.
val output : out_channel -> bytes -> int -> int -> unitoutput oc buf pos len writes len characters from byte sequence buf, starting at offset pos, to the given output channel oc.
val output_substring : out_channel -> string -> int -> int -> unitSame as output but take a string as argument instead of a byte sequence.
val output_byte : out_channel -> int -> unitWrite one 8-bit integer (as the single character with that code) on the given output channel. The given integer is taken modulo 256.
val output_binary_int : out_channel -> int -> unitWrite one integer in binary format (4 bytes, big-endian) on the given output channel. The given integer is taken modulo 232. The only reliable way to read it back is through the Stdlib.input_binary_int function. The format is compatible across all machines for a given version of OCaml.
val output_value : out_channel -> 'a -> unitWrite the representation of a structured value of any type to a channel. Circularities and sharing inside the value are detected and preserved. The object can be read back, by the function Stdlib.input_value. See the description of module Marshal for more information. Stdlib.output_value is equivalent to Marshal.to_channel with an empty list of flags.
val seek_out : out_channel -> int -> unitseek_out chan pos sets the current writing position to pos for channel chan. This works only for regular files. On files of other kinds (such as terminals, pipes and sockets), the behavior is unspecified.
val pos_out : out_channel -> intReturn the current writing position for the given channel. Does not work on channels opened with the Open_append flag (returns unspecified results). For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_out, then going back to this position using seek_out will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
val out_channel_length : out_channel -> intReturn the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless.
val close_out : out_channel -> unitClose the given channel, flushing all buffered write operations. Output functions raise a Sys_error exception when they are applied to a closed output channel, except close_out and flush, which do nothing when applied to an already closed channel. Note that close_out may raise Sys_error if the operating system signals an error when flushing or closing.
val close_out_noerr : out_channel -> unitSame as close_out, but ignore all errors.
val set_binary_mode_out : out_channel -> bool -> unitset_binary_mode_out oc true sets the channel oc to binary mode: no translations take place during output. set_binary_mode_out oc false sets the channel oc to text mode: depending on the operating system, some translations may take place during output. For instance, under Windows, end-of-lines will be translated from \n to \r\n. This function has no effect under operating systems that do not distinguish between text mode and binary mode.
val open_in : string -> in_channelOpen the named file for reading, and return a new input channel on that file, positioned at the beginning of the file.
val open_in_bin : string -> in_channelSame as Stdlib.open_in, but the file is opened in binary mode, so that no translation takes place during reads. On operating systems that do not distinguish between text mode and binary mode, this function behaves like Stdlib.open_in.
val open_in_gen : open_flag list -> int -> string -> in_channelopen_in_gen mode perm filename opens the named file for reading, as described above. The extra arguments mode and perm specify the opening mode and file permissions. Stdlib.open_in and Stdlib.open_in_bin are special cases of this function.
val input_char : in_channel -> charRead one character from the given input channel.
val input_line : in_channel -> stringRead characters from the given input channel, until a newline character is encountered. Return the string of all characters read, without the newline character at the end.
val input : in_channel -> bytes -> int -> int -> intinput ic buf pos len reads up to len characters from the given channel ic, storing them in byte sequence buf, starting at character number pos. It returns the actual number of characters read, between 0 and len (inclusive). A return value of 0 means that the end of file was reached. A return value between 0 and len exclusive means that not all requested len characters were read, either because no more characters were available at that time, or because the implementation found it convenient to do a partial read; input must be called again to read the remaining characters, if desired. (See also Stdlib.really_input for reading exactly len characters.) Exception Invalid_argument "input" is raised if pos and len do not designate a valid range of buf.
val really_input : in_channel -> bytes -> int -> int -> unitreally_input ic buf pos len reads len characters from channel ic, storing them in byte sequence buf, starting at character number pos.
val really_input_string : in_channel -> int -> stringreally_input_string ic len reads len characters from channel ic and returns them in a new string.
val input_byte : in_channel -> intSame as Stdlib.input_char, but return the 8-bit integer representing the character.
val input_binary_int : in_channel -> intRead an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Stdlib.output_binary_int.
val input_value : in_channel -> 'aRead the representation of a structured value, as produced by Stdlib.output_value, and return the corresponding value. This function is identical to Marshal.from_channel; see the description of module Marshal for more information, in particular concerning the lack of type safety.
val seek_in : in_channel -> int -> unitseek_in chan pos sets the current reading position to pos for channel chan. This works only for regular files. On files of other kinds, the behavior is unspecified.
val pos_in : in_channel -> intReturn the current reading position for the given channel. For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_in, then going back to this position using seek_in will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
val in_channel_length : in_channel -> intReturn the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless. The returned size does not take into account the end-of-line translations that can be performed when reading from a channel opened in text mode.
val close_in : in_channel -> unitClose the given channel. Input functions raise a Sys_error exception when they are applied to a closed input channel, except close_in, which does nothing when applied to an already closed channel.
val close_in_noerr : in_channel -> unitSame as close_in, but ignore all errors.
val set_binary_mode_in : in_channel -> bool -> unitset_binary_mode_in ic true sets the channel ic to binary mode: no translations take place during input. set_binary_mode_out ic false sets the channel ic to text mode: depending on the operating system, some translations may take place during input. For instance, under Windows, end-of-lines will be translated from \r\n to \n. This function has no effect under operating systems that do not distinguish between text mode and binary mode.
module LargeFile : sig ... endOperations on large files. This sub-module provides 64-bit variants of the channel functions that manipulate file positions and file sizes. By representing positions and sizes by 64-bit integers (type int64) instead of regular integers (type int), these alternate functions allow operating on files whose sizes are greater than max_int.
The type of references (mutable indirection cells) containing a value of type 'a.
val ref : 'a -> 'a refReturn a fresh reference containing the given value.
val (!) : 'a ref -> 'a!r returns the current contents of reference r. Equivalent to fun r -> r.contents. Unary operator, see Ocaml_operators for more information.
val (:=) : 'a ref -> 'a -> unitr := a stores the value of a in reference r. Equivalent to fun r v -> r.contents <- v. Right-associative operator, see Ocaml_operators for more information.
val incr : int ref -> unitIncrement the integer contained in the given reference. Equivalent to fun r -> r := succ !r.
val decr : int ref -> unitDecrement the integer contained in the given reference. Equivalent to fun r -> r := pred !r.
Format strings are character strings with special lexical conventions that defines the functionality of formatted input/output functions. Format strings are used to read data with formatted input functions from module Scanf and to print data with formatted output functions from modules Printf and Format.
Format strings are made of three kinds of entities:
'%' followed by one or more characters specifying what kind of argument to read or print,'@' followed by one or more characters specifying how to read or print the argument,There is an additional lexical rule to escape the special characters '%' and '@' in format strings: if a special character follows a '%' character, it is treated as a plain character. In other words, "%%" is considered as a plain '%' and "%@" as a plain '@'.
For more information about conversion specifications and formatting indications available, read the documentation of modules Scanf, Printf and Format.
Format strings have a general and highly polymorphic type ('a, 'b, 'c, 'd, 'e, 'f) format6. The two simplified types, format and format4 below are included for backward compatibility with earlier releases of OCaml.
The meaning of format string type parameters is as follows:
'a is the type of the parameters of the format for formatted output functions (printf-style functions); 'a is the type of the values read by the format for formatted input functions (scanf-style functions).'b is the type of input source for formatted input functions and the type of output target for formatted output functions. For printf-style functions from module Printf, 'b is typically out_channel; for printf-style functions from module Format, 'b is typically Format.formatter; for scanf-style functions from module Scanf, 'b is typically Scanf.Scanning.in_channel.Type argument 'b is also the type of the first argument given to user's defined printing functions for %a and %t conversions, and user's defined reading functions for %r conversion.
'c is the type of the result of the %a and %t printing functions, and also the type of the argument transmitted to the first argument of kprintf-style functions or to the kscanf-style functions.'d is the type of parameters for the scanf-style functions.'e is the type of the receiver function for the scanf-style functions.'f is the final result type of a formatted input/output function invocation: for the printf-style functions, it is typically unit; for the scanf-style functions, it is typically the result type of the receiver function.type ('a, 'b, 'c, 'd, 'e, 'f) format6 =
+ ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> stringConverts a format string into a string.
format_of_string s returns a format string read from the string literal s. Note: format_of_string can not convert a string argument that is not a literal. If you need this functionality, use the more general Scanf.format_from_string function.
val (^^) :
+ ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
+ ('f, 'b, 'c, 'e, 'g, 'h) format6 ->
+ ('a, 'b, 'c, 'd, 'g, 'h) format6f1 ^^ f2 catenates format strings f1 and f2. The result is a format string that behaves as the concatenation of format strings f1 and f2: in case of formatted output, it accepts arguments from f1, then arguments from f2; in case of formatted input, it returns results from f1, then results from f2. Right-associative operator, see Ocaml_operators for more information.
Terminate the process, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. All open output channels are flushed with flush_all. An implicit exit 0 is performed each time a program terminates normally. An implicit exit 2 is performed if the program terminates early because of an uncaught exception.
Register the given function to be called at program termination time. The functions registered with at_exit will be called when the program does any of the following:
Stdlib.exitcaml_shutdown. The functions are called in 'last in, first out' order: the function most recently added with at_exit is called first.module Arg : sig ... endParsing of command line arguments.
module Array : sig ... endArray operations.
module ArrayLabels : sig ... endArray operations.
module Atomic : sig ... endThis module provides a purely sequential implementation of the concurrent atomic references provided by the Multicore OCaml standard library:
module Bigarray : sig ... endLarge, multi-dimensional, numerical arrays.
module Bool : sig ... endBoolean values.
module Buffer : sig ... endExtensible buffers.
module Bytes : sig ... endByte sequence operations.
module BytesLabels : sig ... endByte sequence operations.
module Callback : sig ... endRegistering OCaml values with the C runtime.
module Char : sig ... endCharacter operations.
module Complex : sig ... endComplex numbers.
module Digest : sig ... endMD5 message digest.
module Either : sig ... endEither type.
module Ephemeron : sig ... endEphemerons and weak hash tables.
module Filename : sig ... endOperations on file names.
module Float : sig ... endFloating-point arithmetic.
module Format : sig ... endPretty-printing.
module Fun : sig ... endFunction manipulation.
module Gc : sig ... endMemory management control and statistics; finalised values.
module Genlex : sig ... endmodule Hashtbl : sig ... endHash tables and hash functions.
module In_channel : sig ... endInput channels.
module Int : sig ... endInteger values.
module Int32 : sig ... end32-bit integers.
module Int64 : sig ... end64-bit integers.
module Lazy : sig ... endDeferred computations.
module Lexing : sig ... endThe run-time library for lexers generated by ocamllex.
module List : sig ... endList operations.
module ListLabels : sig ... endList operations.
module Map : sig ... endAssociation tables over ordered types.
module Marshal : sig ... endMarshaling of data structures.
module MoreLabels : sig ... endExtra labeled libraries.
module Nativeint : sig ... endProcessor-native integers.
module Obj : sig ... endOperations on internal representations of values.
module Oo : sig ... endOperations on objects
module Option : sig ... endOption values.
module Out_channel : sig ... endOutput channels.
module Parsing : sig ... endThe run-time library for parsers generated by ocamlyacc.
module Pervasives : sig ... endmodule Printexc : sig ... endFacilities for printing exceptions and inspecting current call stack.
module Printf : sig ... endFormatted output functions.
module Queue : sig ... endFirst-in first-out queues.
module Random : sig ... endPseudo-random number generators (PRNG).
module Result : sig ... endResult values.
module Scanf : sig ... endFormatted input functions.
module Seq : sig ... endSequences.
module Set : sig ... endSets over ordered types.
module Stack : sig ... endLast-in first-out stacks.
module StdLabels : sig ... endStandard labeled libraries.
module Stream : sig ... endmodule String : sig ... endStrings.
module StringLabels : sig ... endStrings.
module Sys : sig ... endSystem interface.
module Uchar : sig ... endUnicode characters.
module Unit : sig ... endUnit values.
module Weak : sig ... endArrays of weak pointers and hash sets of weak pointers.
Stdlib__ArgStdlib__ArrayStdlib__ArrayLabelsStdlib__AtomicStdlib__BigarrayStdlib__BoolStdlib__BufferStdlib__BytesStdlib__BytesLabelsStdlib__CallbackStdlib__CharStdlib__ComplexStdlib__DigestStdlib__EitherStdlib__EphemeronStdlib__FilenameStdlib__FloatStdlib__FormatStdlib__FunStdlib__GcStdlib__GenlexStdlib__HashtblStdlib__In_channelStdlib__IntStdlib__Int32Stdlib__Int64Stdlib__LazyStdlib__LexingStdlib__ListStdlib__ListLabelsStdlib__MapStdlib__MarshalStdlib__MoreLabelsStdlib__NativeintStdlib__ObjStdlib__OoStdlib__OptionStdlib__Out_channelStdlib__ParsingStdlib__PervasivesStdlib__PrintexcStdlib__PrintfStdlib__QueueStdlib__RandomStdlib__ResultStdlib__ScanfStdlib__SeqStdlib__SetStdlib__StackStdlib__StdLabelsStdlib__StreamStdlib__StringStdlib__StringLabelsStdlib__SysStdlib__UcharStdlib__UnitStdlib__WeakStrRegular expressions and high-level string processing
val regexp : string -> regexpCompile a regular expression. The following constructs are recognized:
. Matches any character except newline.* (postfix) Matches the preceding expression zero, one or several times+ (postfix) Matches the preceding expression one or several times? (postfix) Matches the preceding expression once or not at all[..] Character set. Ranges are denoted with -, as in [a-z]. An initial ^, as in [^0-9], complements the set. To include a ] character in a set, make it the first character of the set. To include a - character in a set, make it the first or the last character of the set.^ Matches at beginning of line: either at the beginning of the matched string, or just after a '\n' character.$ Matches at end of line: either at the end of the matched string, or just before a '\n' character.\| (infix) Alternative between two expressions.\(..\) Grouping and naming of the enclosed expression.\1 The text matched by the first \(...\) expression (\2 for the second expression, and so on up to \9).\b Matches word boundaries.\ Quotes special characters. The special characters are $^\.*+?[].In regular expressions you will often use backslash characters; it's easier to use a quoted string literal {|...|} to avoid having to escape backslashes.
For example, the following expression:
let r = Str.regexp {|hello \([A-Za-z]+\)|} in
+Str.replace_first r {|\1|} "hello world" returns the string "world".
If you want a regular expression that matches a literal backslash character, you need to double it: Str.regexp {|\\|}.
You can use regular string literals "..." too, however you will have to escape backslashes. The example above can be rewritten with a regular string literal as:
let r = Str.regexp "hello \\([A-Za-z]+\\)" in
+Str.replace_first r "\\1" "hello world" And the regular expression for matching a backslash becomes a quadruple backslash: Str.regexp "\\\\".
val regexp_case_fold : string -> regexpSame as regexp, but the compiled expression will match text in a case-insensitive way: uppercase and lowercase letters will be considered equivalent.
Str.quote s returns a regexp string that matches exactly s and nothing else.
val regexp_string : string -> regexpStr.regexp_string s returns a regular expression that matches exactly s and nothing else.
val regexp_string_case_fold : string -> regexpStr.regexp_string_case_fold is similar to Str.regexp_string, but the regexp matches in a case-insensitive way.
val string_match : regexp -> string -> int -> boolstring_match r s start tests whether a substring of s that starts at position start matches the regular expression r. The first character of a string has position 0, as usual.
val search_forward : regexp -> string -> int -> intsearch_forward r s start searches the string s for a substring matching the regular expression r. The search starts at position start and proceeds towards the end of the string. Return the position of the first character of the matched substring.
val search_backward : regexp -> string -> int -> intsearch_backward r s last searches the string s for a substring matching the regular expression r. The search first considers substrings that start at position last and proceeds towards the beginning of string. Return the position of the first character of the matched substring.
val string_partial_match : regexp -> string -> int -> boolSimilar to Str.string_match, but also returns true if the argument string is a prefix of a string that matches. This includes the case of a true complete match.
matched_string s returns the substring of s that was matched by the last call to one of the following matching or searching functions:
Str.string_matchStr.search_forwardStr.search_backwardStr.string_partial_matchStr.global_substituteStr.substitute_firstprovided that none of the following functions was called in between:
Str.global_replaceStr.replace_firstStr.splitStr.bounded_splitStr.split_delimStr.bounded_split_delimStr.full_splitStr.bounded_full_splitNote: in the case of global_substitute and substitute_first, a call to matched_string is only valid within the subst argument, not after global_substitute or substitute_first returns.
The user must make sure that the parameter s is the same string that was passed to the matching or searching function.
match_beginning() returns the position of the first character of the substring that was matched by the last call to a matching or searching function (see Str.matched_string for details).
match_end() returns the position of the character following the last character of the substring that was matched by the last call to a matching or searching function (see Str.matched_string for details).
matched_group n s returns the substring of s that was matched by the nth group \(...\) of the regular expression that was matched by the last call to a matching or searching function (see Str.matched_string for details). When n is 0, it returns the substring matched by the whole regular expression. The user must make sure that the parameter s is the same string that was passed to the matching or searching function.
group_beginning n returns the position of the first character of the substring that was matched by the nth group of the regular expression that was matched by the last call to a matching or searching function (see Str.matched_string for details).
group_end n returns the position of the character following the last character of substring that was matched by the nth group of the regular expression that was matched by the last call to a matching or searching function (see Str.matched_string for details).
val global_replace : regexp -> string -> string -> stringglobal_replace regexp templ s returns a string identical to s, except that all substrings of s that match regexp have been replaced by templ. The replacement template templ can contain \1, \2, etc; these sequences will be replaced by the text matched by the corresponding group in the regular expression. \0 stands for the text matched by the whole regular expression.
val replace_first : regexp -> string -> string -> stringSame as Str.global_replace, except that only the first substring matching the regular expression is replaced.
val global_substitute : regexp -> (string -> string) -> string -> stringglobal_substitute regexp subst s returns a string identical to s, except that all substrings of s that match regexp have been replaced by the result of function subst. The function subst is called once for each matching substring, and receives s (the whole text) as argument.
val substitute_first : regexp -> (string -> string) -> string -> stringSame as Str.global_substitute, except that only the first substring matching the regular expression is replaced.
replace_matched repl s returns the replacement text repl in which \1, \2, etc. have been replaced by the text matched by the corresponding groups in the regular expression that was matched by the last call to a matching or searching function (see Str.matched_string for details). s must be the same string that was passed to the matching or searching function.
val split : regexp -> string -> string listsplit r s splits s into substrings, taking as delimiters the substrings that match r, and returns the list of substrings. For instance, split (regexp "[ \t]+") s splits s into blank-separated words. An occurrence of the delimiter at the beginning or at the end of the string is ignored.
val bounded_split : regexp -> string -> int -> string listSame as Str.split, but splits into at most n substrings, where n is the extra integer parameter.
val split_delim : regexp -> string -> string listSame as Str.split but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result. For instance, split_delim (regexp " ") " abc " returns [""; "abc"; ""], while split with the same arguments returns ["abc"].
val bounded_split_delim : regexp -> string -> int -> string listSame as Str.bounded_split, but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.
val full_split : regexp -> string -> split_result listSame as Str.split_delim, but returns the delimiters as well as the substrings contained between delimiters. The former are tagged Delim in the result list; the latter are tagged Text. For instance, full_split (regexp "[{}]") "{ab}" returns [Delim "{"; Text "ab"; Delim "}"].
val bounded_full_split : regexp -> string -> int -> split_result listSame as Str.bounded_split_delim, but returns the delimiters as well as the substrings contained between delimiters. The former are tagged Delim in the result list; the latter are tagged Text.
string_before s n returns the substring of all characters of s that precede position n (excluding the character at position n).
string_after s n returns the substring of all characters of s that follow position n (including the character at position n).
first_chars s n returns the first n characters of s. This is the same function as Str.string_before.
Make._val string_block_length : Cmm.expression -> Cmm.expressionval transl_switch :
+ Debuginfo.t ->
+ Cmm.expression ->
+ int ->
+ int ->
+ (int * Cmm.expression) list ->
+ Cmm.expression ->
+ Cmm.expressionStrmatch.Makeval compile :
+ Debuginfo.t ->
+ Cmm.expression ->
+ Cmm.expression option ->
+ (string * Cmm.expression) list ->
+ Cmm.expressionStrmatchStrmatch.Ival string_block_length : Cmm.expression -> Cmm.expressionval transl_switch :
+ Debuginfo.t ->
+ Cmm.expression ->
+ int ->
+ int ->
+ (int * Cmm.expression) list ->
+ Cmm.expression ->
+ Cmm.expressionId.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitId.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringId.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitId.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tMake.Idmodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := TStrongly_connected_components.Makemodule Id : Identifiable.SIf (a -> set) belongs to the map, it means that there are edges from a to every element of set. It is assumed that no edge points to a vertex not represented in the map.
val connected_components_sorted_from_roots_to_leaf :
+ directed_graph ->
+ component arrayval component_graph : directed_graph -> (component * int list) arrayStrongly_connected_componentsKosaraju's algorithm for strongly connected components.
Warning: this module is unstable and part of compiler-libs.
Id.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitId.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringId.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitId.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tS.Idmodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := TStrongly_connected_components.Smodule Id : Identifiable.SIf (a -> set) belongs to the map, it means that there are edges from a to every element of set. It is assumed that no edge points to a vertex not represented in the map.
val connected_components_sorted_from_roots_to_leaf :
+ directed_graph ->
+ component arrayval component_graph : directed_graph -> (component * int list) arrayStypestype annotation = | Ti_pat : 'k Typedtree.pattern_category
+ * 'k Typedtree.general_pattern -> annotation| Ti_expr of Typedtree.expression| Ti_class of Typedtree.class_expr| Ti_mod of Typedtree.module_expr| An_call of Location.t * Annot.call| An_ident of Location.t * string * Annot.identval record : annotation -> unitval record_phrase : Location.t -> unitval get_location : annotation -> Location.tval get_info : unit -> annotation listSubst.Lazytype module_decl = {mdl_type : modtype;mdl_attributes : Parsetree.attributes;mdl_loc : Location.t;mdl_uid : Types.Uid.t;}and modtype = | MtyL_ident of Path.t| MtyL_signature of signature| MtyL_functor of functor_parameter * modtype| MtyL_alias of Path.tand modtype_declaration = {mtdl_type : modtype option;mtdl_attributes : Parsetree.attributes;mtdl_loc : Location.t;mtdl_uid : Types.Uid.t;}and signature_item = | SigL_value of Ident.t * Types.value_description * Types.visibility| SigL_type of Ident.t
+ * Types.type_declaration
+ * Types.rec_status
+ * Types.visibility| SigL_typext of Ident.t
+ * Types.extension_constructor
+ * Types.ext_status
+ * Types.visibility| SigL_module of Ident.t
+ * Types.module_presence
+ * module_decl
+ * Types.rec_status
+ * Types.visibility| SigL_modtype of Ident.t * modtype_declaration * Types.visibility| SigL_class of Ident.t
+ * Types.class_declaration
+ * Types.rec_status
+ * Types.visibility| SigL_class_type of Ident.t
+ * Types.class_type_declaration
+ * Types.rec_status
+ * Types.visibilityval of_module_decl : Types.module_declaration -> module_declval of_modtype : Types.module_type -> modtypeval of_modtype_decl : Types.modtype_declaration -> modtype_declarationval of_signature : Types.signature -> signatureval of_signature_items : signature_item list -> signatureval of_signature_item : Types.signature_item -> signature_itemval module_decl : scoping -> t -> module_decl -> module_declval modtype_decl : scoping -> t -> modtype_declaration -> modtype_declarationval signature_item : scoping -> t -> signature_item -> signature_itemval force_module_decl : module_decl -> Types.module_declarationval force_modtype : modtype -> Types.module_typeval force_modtype_decl : modtype_declaration -> Types.modtype_declarationval force_signature : signature -> Types.signatureval force_signature_once : signature -> signature_item listval force_signature_item : signature_item -> Types.signature_itemSubstval identity : tval add_type_function :
+ Path.t ->
+ params:Types.type_expr list ->
+ body:Types.type_expr ->
+ t ->
+ tval add_modtype : Ident.t -> Types.module_type -> t -> tval add_modtype_path : Path.t -> Types.module_type -> t -> tval change_locs : t -> Location.t -> tval type_expr : t -> Types.type_expr -> Types.type_exprval class_type : t -> Types.class_type -> Types.class_typeval value_description : t -> Types.value_description -> Types.value_descriptionval type_declaration : t -> Types.type_declaration -> Types.type_declarationval extension_constructor :
+ t ->
+ Types.extension_constructor ->
+ Types.extension_constructorval class_declaration : t -> Types.class_declaration -> Types.class_declarationval cltype_declaration :
+ t ->
+ Types.class_type_declaration ->
+ Types.class_type_declarationval modtype : scoping -> t -> Types.module_type -> Types.module_typeval signature : scoping -> t -> Types.signature -> Types.signatureval signature_item :
+ scoping ->
+ t ->
+ Types.signature_item ->
+ Types.signature_itemval modtype_declaration :
+ scoping ->
+ t ->
+ Types.modtype_declaration ->
+ Types.modtype_declarationval module_declaration :
+ scoping ->
+ t ->
+ Types.module_declaration ->
+ Types.module_declarationval ctype_apply_env_empty :
+ (Types.type_expr list ->
+ Types.type_expr ->
+ Types.type_expr list ->
+ Types.type_expr)
+ refmodule Lazy : sig ... endCtxStore.ASwitch.CtxStoreMake.Argval eqint : primitiveval neint : primitiveval leint : primitiveval ltint : primitiveval geint : primitiveval gtint : primitiveval make_const : int -> argval make_exit : int -> actSwitch.MakeStore.ASwitch.StoreSwitchSwitch.CtxStoredSwitch.Sval eqint : primitiveval neint : primitiveval leint : primitiveval ltint : primitiveval geint : primitiveval gtint : primitiveval make_const : int -> argval make_exit : int -> actSwitch.StoredSymbol.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitSymbol.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringSymbol.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitSymbol.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tSymbolA symbol identifies a constant provided by either:
* sym_unit is the compilation unit containing the value. * sym_label is the linkage name of the variable.
The label must be globally unique: two compilation units linked in the same program must not share labels.
include Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval of_variable : Variable.t -> tval of_global_linkage : Compilation_unit.t -> Linkage_name.t -> tval import_for_pack : pack:Compilation_unit.t -> t -> tval compilation_unit : t -> Compilation_unit.tval label : t -> Linkage_name.tval print_opt : Stdlib.Format.formatter -> t option -> unitSymtableval patch_object :
+ Misc.LongString.t ->
+ (Cmo_format.reloc_info * int) list ->
+ unitval initial_global_table : unit -> Stdlib.Obj.t arrayval output_global_map : out_channel -> unitval output_primitive_names : out_channel -> unitval output_primitive_table : out_channel -> unitval data_global_map : unit -> Stdlib.Obj.tval transl_const : Lambda.structured_constant -> Stdlib.Obj.tval init_toplevel : unit -> (string * Stdlib.Digest.t option) listval get_global_value : Ident.t -> Stdlib.Obj.tval is_global_defined : Ident.t -> boolval assign_global_value : Ident.t -> Stdlib.Obj.t -> unitval get_global_position : Ident.t -> intval check_global_initialized : (Cmo_format.reloc_info * int) list -> unitval defined_globals : (Cmo_format.reloc_info * int) list -> Ident.t listval required_globals : (Cmo_format.reloc_info * int) list -> Ident.t listval empty_global_map : global_mapval current_state : unit -> global_mapval restore_state : global_map -> unitval hide_additions : global_map -> unitval filter_global_map : (Ident.t -> bool) -> global_map -> global_mapval iter_global_map : (Ident.t -> int -> unit) -> global_map -> unitval is_defined_in_global_map : global_map -> Ident.t -> boolexception Error of errorval report_error : Stdlib.Format.formatter -> error -> unitSyntaxerrAuxiliary type for reporting syntax errors
Warning: this module is unstable and part of compiler-libs.
type error = | Unclosed of Location.t * string * Location.t * string| Expecting of Location.t * string| Not_expecting of Location.t * string| Applicative_path of Location.t| Variable_in_scope of Location.t * string| Other of Location.t| Ill_formed_ast of Location.t * string| Invalid_package_type of Location.t * stringexception Error of errorval location_of_error : error -> Location.tval ill_formed_ast : Location.t -> string -> 'aTag.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitTag.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringTag.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitTag.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tTagTags on runtime boxed values.
include Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tval output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create_exn : int -> tval to_int : t -> intval zero : tval object_tag : tTargetintTarget processor-native integers.
This module provides operations on the type of signed 32-bit integers (on 32-bit target platforms) or signed 64-bit integers (on 64-bit target platforms). This integer type has exactly the same width as that of a pointer type in the C compiler. All arithmetic operations over are taken modulo 232 or 264 depending on the word size of the target architecture.
Warning: this module is unstable and part of compiler-libs.
val zero : tThe target integer 0.
val one : tThe target integer 1.
val minus_one : tThe target integer -1.
Integer division. Raise Division_by_zero if the second argument is zero. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/).
Same as div, except that arguments and result are interpreted as unsigned integers.
Integer remainder. If y is not zero, the result of Targetint.rem x y satisfies the following properties: Targetint.zero <= Nativeint.rem x y < Targetint.abs y and x = Targetint.add (Targetint.mul (Targetint.div x y) y)
+ (Targetint.rem x y). If y = 0, Targetint.rem x y raises Division_by_zero.
Same as rem, except that arguments and result are interpreted as unsigned integers.
val max_int : tThe greatest representable target integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
val min_int : tThe smallest representable target integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
Targetint.shift_left x y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= bitsize, where bitsize is 32 on a 32-bit platform and 64 on a 64-bit platform.
Targetint.shift_right x y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= bitsize.
Targetint.shift_right_logical x y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= bitsize.
val of_int : int -> tConvert the given integer (type int) to a target integer (type t), module the target word size.
val of_int_exn : int -> tConvert the given integer (type int) to a target integer (type t). Raises a fatal error if the conversion is not exact.
val to_int : t -> intConvert the given target integer (type t) to an integer (type int). The high-order bit is lost during the conversion.
val of_float : float -> tConvert the given floating-point number to a target integer, discarding the fractional part (truncate towards 0). The result of the conversion is undefined if, after truncation, the number is outside the range [Targetint.min_int, Targetint.max_int].
val to_float : t -> floatConvert the given target integer to a floating-point number.
val of_int32 : int32 -> tConvert the given 32-bit integer (type int32) to a target integer.
val to_int32 : t -> int32Convert the given target integer to a 32-bit integer (type int32). On 64-bit platforms, the 64-bit native integer is taken modulo 232, i.e. the top 32 bits are lost. On 32-bit platforms, the conversion is exact.
val of_int64 : int64 -> tConvert the given 64-bit integer (type int64) to a target integer.
val to_int64 : t -> int64Convert the given target integer to a 64-bit integer (type int64).
val of_string : string -> tConvert the given string to a target integer. The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively. Raise Failure "int_of_string" if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type nativeint.
val to_string : t -> stringReturn the string representation of its argument, in decimal.
The comparison function for target integers, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Targetint to be passed as argument to the functors Set.Make and Map.Make.
Same as compare, except that arguments are interpreted as unsigned integers.
val print : Stdlib.Format.formatter -> t -> unitPrint a target integer to a formatter.
Tast_iteratorAllows the implementation of typed tree inspection using open recursion
type iterator = {binding_op : iterator -> Typedtree.binding_op -> unit;case : 'k. iterator -> 'k Typedtree.case -> unit;class_declaration : iterator -> Typedtree.class_declaration -> unit;class_description : iterator -> Typedtree.class_description -> unit;class_expr : iterator -> Typedtree.class_expr -> unit;class_field : iterator -> Typedtree.class_field -> unit;class_signature : iterator -> Typedtree.class_signature -> unit;class_structure : iterator -> Typedtree.class_structure -> unit;class_type : iterator -> Typedtree.class_type -> unit;class_type_declaration : iterator -> Typedtree.class_type_declaration -> unit;class_type_field : iterator -> Typedtree.class_type_field -> unit;env : iterator -> Env.t -> unit;expr : iterator -> Typedtree.expression -> unit;extension_constructor : iterator -> Typedtree.extension_constructor -> unit;module_binding : iterator -> Typedtree.module_binding -> unit;module_coercion : iterator -> Typedtree.module_coercion -> unit;module_declaration : iterator -> Typedtree.module_declaration -> unit;module_substitution : iterator -> Typedtree.module_substitution -> unit;module_expr : iterator -> Typedtree.module_expr -> unit;module_type : iterator -> Typedtree.module_type -> unit;module_type_declaration : iterator ->
+ Typedtree.module_type_declaration ->
+ unit;package_type : iterator -> Typedtree.package_type -> unit;pat : 'k. iterator -> 'k Typedtree.general_pattern -> unit;row_field : iterator -> Typedtree.row_field -> unit;object_field : iterator -> Typedtree.object_field -> unit;open_declaration : iterator -> Typedtree.open_declaration -> unit;open_description : iterator -> Typedtree.open_description -> unit;signature : iterator -> Typedtree.signature -> unit;signature_item : iterator -> Typedtree.signature_item -> unit;structure : iterator -> Typedtree.structure -> unit;structure_item : iterator -> Typedtree.structure_item -> unit;typ : iterator -> Typedtree.core_type -> unit;type_declaration : iterator -> Typedtree.type_declaration -> unit;type_declarations : iterator ->
+ (Asttypes.rec_flag * Typedtree.type_declaration list) ->
+ unit;type_extension : iterator -> Typedtree.type_extension -> unit;type_exception : iterator -> Typedtree.type_exception -> unit;type_kind : iterator -> Typedtree.type_kind -> unit;value_binding : iterator -> Typedtree.value_binding -> unit;value_bindings : iterator ->
+ (Asttypes.rec_flag * Typedtree.value_binding list) ->
+ unit;value_description : iterator -> Typedtree.value_description -> unit;with_constraint : iterator -> Typedtree.with_constraint -> unit;}val default_iterator : iteratorTast_mappertype mapper = {binding_op : mapper -> Typedtree.binding_op -> Typedtree.binding_op;case : 'k. mapper -> 'k Typedtree.case -> 'k Typedtree.case;class_declaration : mapper ->
+ Typedtree.class_declaration ->
+ Typedtree.class_declaration;class_description : mapper ->
+ Typedtree.class_description ->
+ Typedtree.class_description;class_expr : mapper -> Typedtree.class_expr -> Typedtree.class_expr;class_field : mapper -> Typedtree.class_field -> Typedtree.class_field;class_signature : mapper ->
+ Typedtree.class_signature ->
+ Typedtree.class_signature;class_structure : mapper ->
+ Typedtree.class_structure ->
+ Typedtree.class_structure;class_type : mapper -> Typedtree.class_type -> Typedtree.class_type;class_type_declaration : mapper ->
+ Typedtree.class_type_declaration ->
+ Typedtree.class_type_declaration;class_type_field : mapper ->
+ Typedtree.class_type_field ->
+ Typedtree.class_type_field;env : mapper -> Env.t -> Env.t;expr : mapper -> Typedtree.expression -> Typedtree.expression;extension_constructor : mapper ->
+ Typedtree.extension_constructor ->
+ Typedtree.extension_constructor;module_binding : mapper ->
+ Typedtree.module_binding ->
+ Typedtree.module_binding;module_coercion : mapper ->
+ Typedtree.module_coercion ->
+ Typedtree.module_coercion;module_declaration : mapper ->
+ Typedtree.module_declaration ->
+ Typedtree.module_declaration;module_substitution : mapper ->
+ Typedtree.module_substitution ->
+ Typedtree.module_substitution;module_expr : mapper -> Typedtree.module_expr -> Typedtree.module_expr;module_type : mapper -> Typedtree.module_type -> Typedtree.module_type;module_type_declaration : mapper ->
+ Typedtree.module_type_declaration ->
+ Typedtree.module_type_declaration;package_type : mapper -> Typedtree.package_type -> Typedtree.package_type;pat : 'k. mapper ->
+ 'k Typedtree.general_pattern ->
+ 'k Typedtree.general_pattern;row_field : mapper -> Typedtree.row_field -> Typedtree.row_field;object_field : mapper -> Typedtree.object_field -> Typedtree.object_field;open_declaration : mapper ->
+ Typedtree.open_declaration ->
+ Typedtree.open_declaration;open_description : mapper ->
+ Typedtree.open_description ->
+ Typedtree.open_description;signature : mapper -> Typedtree.signature -> Typedtree.signature;signature_item : mapper ->
+ Typedtree.signature_item ->
+ Typedtree.signature_item;structure : mapper -> Typedtree.structure -> Typedtree.structure;structure_item : mapper ->
+ Typedtree.structure_item ->
+ Typedtree.structure_item;typ : mapper -> Typedtree.core_type -> Typedtree.core_type;type_declaration : mapper ->
+ Typedtree.type_declaration ->
+ Typedtree.type_declaration;type_declarations : mapper ->
+ (Asttypes.rec_flag * Typedtree.type_declaration list) ->
+ Asttypes.rec_flag * Typedtree.type_declaration list;type_extension : mapper ->
+ Typedtree.type_extension ->
+ Typedtree.type_extension;type_exception : mapper ->
+ Typedtree.type_exception ->
+ Typedtree.type_exception;type_kind : mapper -> Typedtree.type_kind -> Typedtree.type_kind;value_binding : mapper -> Typedtree.value_binding -> Typedtree.value_binding;value_bindings : mapper ->
+ (Asttypes.rec_flag * Typedtree.value_binding list) ->
+ Asttypes.rec_flag * Typedtree.value_binding list;value_description : mapper ->
+ Typedtree.value_description ->
+ Typedtree.value_description;with_constraint : mapper ->
+ Typedtree.with_constraint ->
+ Typedtree.with_constraint;}val default : mapperTerminfoBasic interface to the terminfo database
Warning: this module is unstable and part of compiler-libs.
val setup : out_channel -> statusval num_lines : out_channel -> intval backup : out_channel -> int -> unitval standout : out_channel -> bool -> unitval resume : out_channel -> int -> unitThreadLightweight threads for Posix 1003.1c and Win32.
val create : ('a -> 'b) -> 'a -> tThread.create funct arg creates a new thread of control, in which the function application funct arg is executed concurrently with the other threads of the program. The application of Thread.create returns the handle of the newly created thread. The new thread terminates when the application funct arg returns, either normally or by raising the Thread.Exit exception or by raising any other uncaught exception. In the last case, the uncaught exception is printed on standard error, but not propagated back to the parent thread. Similarly, the result of the application funct arg is discarded and not directly accessible to the parent thread.
val self : unit -> tReturn the handle for the thread currently executing.
val id : t -> intReturn the identifier of the given thread. A thread identifier is an integer that identifies uniquely the thread. It can be used to build data structures indexed by threads.
Exception that can be raised by user code to initiate termination of the current thread. Compared to calling the Thread.exit function, raising the Thread.Exit exception will trigger Fun.finally finalizers and catch-all exception handlers. It is the recommended way to terminate threads prematurely.
val kill : t -> unitThis function was supposed to terminate prematurely the thread whose handle is given. It is not currently implemented due to problems with cleanup handlers on many POSIX 1003.1c implementations. It always raises the Invalid_argument exception.
delay d suspends the execution of the calling thread for d seconds. The other program threads continue to run during this time.
val join : t -> unitjoin th suspends the execution of the calling thread until the thread th has terminated.
Re-schedule the calling thread without suspending it. This function can be used to give scheduling hints, telling the scheduler that now is a good time to switch to other threads.
The functions below are leftovers from an earlier, VM-based threading system. The Unix module provides equivalent functionality, in a more general and more standard-conformant manner. It is recommended to use Unix functions directly.
val wait_read : Unix.file_descr -> unitThis function does nothing in the current implementation of the threading library and can be removed from all user programs.
val wait_write : Unix.file_descr -> unitThis function does nothing in the current implementation of the threading library and can be removed from all user programs.
val wait_timed_read : Unix.file_descr -> float -> boolval wait_timed_write : Unix.file_descr -> float -> boolSuspend the execution of the calling thread until at least one character or EOF is available for reading (wait_timed_read) or one character can be written without blocking (wait_timed_write) on the given Unix file descriptor. Wait for at most the amount of time given as second argument (in seconds). Return true if the file descriptor is ready for input/output and false if the timeout expired. The same functionality can be achieved with Unix.select.
val select :
+ Unix.file_descr list ->
+ Unix.file_descr list ->
+ Unix.file_descr list ->
+ float ->
+ Unix.file_descr list * Unix.file_descr list * Unix.file_descr listSame function as Unix.select. Suspend the execution of the calling thread until input/output becomes possible on the given Unix file descriptors. The arguments and results have the same meaning as for Unix.select.
val wait_pid : int -> int * Unix.process_statusSame function as Unix.waitpid. wait_pid p suspends the execution of the calling thread until the process specified by the process identifier p terminates. Returns the pid of the child caught and its termination status, as per Unix.wait.
Signal handling follows the POSIX thread model: signals generated by a thread are delivered to that thread; signals generated externally are delivered to one of the threads that does not block it. Each thread possesses a set of blocked signals, which can be modified using Thread.sigmask. This set is inherited at thread creation time. Per-thread signal masks are supported only by the system thread library under Unix, but not under Win32, nor by the VM thread library.
val sigmask : Unix.sigprocmask_command -> int list -> int listsigmask cmd sigs changes the set of blocked signals for the calling thread. If cmd is SIG_SETMASK, blocked signals are set to those in the list sigs. If cmd is SIG_BLOCK, the signals in sigs are added to the set of blocked signals. If cmd is SIG_UNBLOCK, the signals in sigs are removed from the set of blocked signals. sigmask returns the set of previously blocked signals for the thread.
wait_signal sigs suspends the execution of the calling thread until the process receives one of the signals specified in the list sigs. It then returns the number of the signal received. Signal handlers attached to the signals in sigs will not be invoked. The signals sigs are expected to be blocked before calling wait_signal.
Thread.default_uncaught_exception_handler will print the thread's id, exception and backtrace (if available).
Thread.set_uncaught_exception_handler fn registers fn as the handler for uncaught exceptions.
If the newly set uncaught exception handler raise an exception, default_uncaught_exception_handler will be called.
ThreadUnixThread-compatible system calls.
val wait : unit -> int * Unix.process_statusval waitpid : Unix.wait_flag list -> int -> int * Unix.process_statusval system : string -> Unix.process_statusval read : Unix.file_descr -> bytes -> int -> int -> intval write : Unix.file_descr -> bytes -> int -> int -> intval write_substring : Unix.file_descr -> string -> int -> int -> intval timed_read : Unix.file_descr -> bytes -> int -> int -> float -> intval timed_write : Unix.file_descr -> bytes -> int -> int -> float -> intBehave as ThreadUnix.read and ThreadUnix.write, except that Unix_error(ETIMEDOUT,_,_) is raised if no data is available for reading or ready for writing after d seconds. The delay d is given in the fifth argument, in seconds.
val timed_write_substring :
+ Unix.file_descr ->
+ string ->
+ int ->
+ int ->
+ float ->
+ intval select :
+ Unix.file_descr list ->
+ Unix.file_descr list ->
+ Unix.file_descr list ->
+ float ->
+ Unix.file_descr list * Unix.file_descr list * Unix.file_descr listval pipe : ?cloexec:bool -> unit -> Unix.file_descr * Unix.file_descrval open_process_in : string -> in_channelval open_process_out : string -> out_channelval open_process : string -> in_channel * out_channelval socket :
+ ?cloexec:bool ->
+ Unix.socket_domain ->
+ Unix.socket_type ->
+ int ->
+ Unix.file_descrval accept :
+ ?cloexec:bool ->
+ Unix.file_descr ->
+ Unix.file_descr * Unix.sockaddrval connect : Unix.file_descr -> Unix.sockaddr -> unitval recv : Unix.file_descr -> bytes -> int -> int -> Unix.msg_flag list -> intval recvfrom :
+ Unix.file_descr ->
+ bytes ->
+ int ->
+ int ->
+ Unix.msg_flag list ->
+ int * Unix.sockaddrval send : Unix.file_descr -> bytes -> int -> int -> Unix.msg_flag list -> intval send_substring :
+ Unix.file_descr ->
+ string ->
+ int ->
+ int ->
+ Unix.msg_flag list ->
+ intval sendto :
+ Unix.file_descr ->
+ bytes ->
+ int ->
+ int ->
+ Unix.msg_flag list ->
+ Unix.sockaddr ->
+ intval sendto_substring :
+ Unix.file_descr ->
+ string ->
+ int ->
+ int ->
+ Unix.msg_flag list ->
+ Unix.sockaddr ->
+ intval open_connection : Unix.sockaddr -> in_channel * out_channelTmcTail-modulo-cons optimization.
Warning: this module is unstable and part of compiler-libs.
TMC (Tail Modulo Cons) is a code transformation that rewrites transformed functions in destination-passing-style, in such a way that certain calls that were not in tail position in the original program become tail-calls in the transformed program.
As a classic example, the following program |
+ let[@tail_mod_cons] rec map f = function
+ | [] -> []
+ | x :: xs ->
+ let y = f x in
+ y :: map f xs
+ | becomes (expressed in almost-source-form; the translation is in fact at the Lambda-level) |
+ let rec map f = function
+ | [] -> []
+ | x :: xs ->
+ let y = f x in
+ let dst = y :: Placeholder in
+ map_dps dst 1 f xs; dst
+ and map_dps dst offset f = function
+ | [] ->
+ dst.offset <- []
+ | x :: xs ->
+ let y = f x in
+ let dst' = y :: Placeholder in
+ dst.offset <- dst';
+ map_dps dst 1 f fx
+ |
In this example, the expression (y :: map f xs) had a call in non-tail-position, and it gets rewritten into tail-calls. TMC handles all such cases where the continuation of the call (what needs to be done after the return) is a "construction", the creation of a (possibly nested) data block.
The code transformation generates two versions of the input function, the "direct" version with the same type and behavior as the original one (here just map), and the "destination-passing-style" version (here map_dps).
Any call to the original function from outside the let..rec declaration gets transformed into a call into the direct version, which will itself call the destination-passing-style versions on recursive calls that may benefit from it (they are in tail-position modulo constructors).
Because of this inherent code duplication, the transformation may not always improve performance. In this implementation, TMC is opt-in, we only transform functions that the user has annotated with an attribute to request the transformation.
val rewrite : Lambda.lambda -> Lambda.lambdaTopcommonThis module provides common implementations for internals of Toploop, for bytecode and native code (see Topeval for the diverging parts of the implementation).
You should not use it directly, refer to the functions in Toploop instead.
val backtrace : string option refval parse_mod_use_file :
+ string ->
+ Stdlib.Lexing.lexbuf ->
+ Parsetree.toplevel_phrase listTopdirsval dir_load : Stdlib.Format.formatter -> string -> unitval dir_use : Stdlib.Format.formatter -> string -> unitval dir_use_output : Stdlib.Format.formatter -> string -> unitval dir_install_printer : Stdlib.Format.formatter -> Longident.t -> unitval dir_remove_printer : Stdlib.Format.formatter -> Longident.t -> unittype 'a printer_type_new = Stdlib.Format.formatter -> 'a -> unitval load_file : Stdlib.Format.formatter -> string -> boolTopevalThis module provides two alternative implementations for internals of Toploop, for bytecode and native code.
You should not use it directly, refer to the functions in Toploop instead.
Tophookstype lookup_fn = string -> Stdlib.Obj.t optiontype load_fn =
+ Stdlib.Format.formatter ->
+ string ->
+ Lambda.program ->
+ Topcommon.evaluation_outcomeval lookup : lookup_fnval load : load_fnToploopval getvalue : string -> Stdlib.Obj.tval setvalue : string -> Stdlib.Obj.t -> unitval filename_of_input : input -> stringval loop : Stdlib.Format.formatter -> unitval run_script : Stdlib.Format.formatter -> input -> string array -> booltype directive_fun = | Directive_none of unit -> unit| Directive_string of string -> unit| Directive_int of int -> unit| Directive_ident of Longident.t -> unit| Directive_bool of bool -> unitval add_directive : string -> directive_fun -> directive_info -> unitval get_directive : string -> directive_fun optionval get_directive_info : string -> directive_info optionval directive_table : (string, directive_fun) Stdlib.Hashtbl.tval directive_info_table : (string, directive_info) Stdlib.Hashtbl.tval print_exception_outcome : Stdlib.Format.formatter -> exn -> unitval execute_phrase :
+ bool ->
+ Stdlib.Format.formatter ->
+ Parsetree.toplevel_phrase ->
+ boolval preprocess_phrase :
+ Stdlib.Format.formatter ->
+ Parsetree.toplevel_phrase ->
+ Parsetree.toplevel_phraseval use_input : Stdlib.Format.formatter -> input -> boolval use_output : Stdlib.Format.formatter -> string -> boolval use_silently : Stdlib.Format.formatter -> input -> boolval mod_use_input : Stdlib.Format.formatter -> input -> boolval use_file : Stdlib.Format.formatter -> string -> boolval eval_module_path : Env.t -> Path.t -> Stdlib.Obj.tval eval_value_path : Env.t -> Path.t -> Stdlib.Obj.tval eval_extension_path : Env.t -> Path.t -> Stdlib.Obj.tval eval_class_path : Env.t -> Path.t -> Stdlib.Obj.tval load_file : Stdlib.Format.formatter -> string -> boolval print_value :
+ Env.t ->
+ Stdlib.Obj.t ->
+ Stdlib.Format.formatter ->
+ Types.type_expr ->
+ unitval print_untyped_exception : Stdlib.Format.formatter -> Stdlib.Obj.t -> unitval install_printer :
+ Path.t ->
+ Types.type_expr ->
+ (Stdlib.Format.formatter -> Stdlib.Obj.t -> unit) ->
+ unitval install_generic_printer :
+ Path.t ->
+ Path.t ->
+ (int ->
+ (int ->
+ Stdlib.Obj.t ->
+ Outcometree.out_value,
+ Stdlib.Obj.t ->
+ Outcometree.out_value)
+ gen_printer) ->
+ unitval install_generic_printer' :
+ Path.t ->
+ Path.t ->
+ (Stdlib.Format.formatter ->
+ Stdlib.Obj.t ->
+ unit,
+ Stdlib.Format.formatter ->
+ Stdlib.Obj.t ->
+ unit)
+ gen_printer ->
+ unitval remove_printer : Path.t -> unitval max_printer_depth : int refval max_printer_steps : int refval parse_toplevel_phrase :
+ (Stdlib.Lexing.lexbuf -> Parsetree.toplevel_phrase) refval parse_use_file :
+ (Stdlib.Lexing.lexbuf -> Parsetree.toplevel_phrase list) refval print_location : Stdlib.Format.formatter -> Location.t -> unitval print_error : Stdlib.Format.formatter -> Location.error -> unitval print_warning : Location.t -> Stdlib.Format.formatter -> Warnings.t -> unitval input_name : string refval print_out_value :
+ (Stdlib.Format.formatter -> Outcometree.out_value -> unit) refval print_out_type :
+ (Stdlib.Format.formatter -> Outcometree.out_type -> unit) refval print_out_class_type :
+ (Stdlib.Format.formatter -> Outcometree.out_class_type -> unit) refval print_out_module_type :
+ (Stdlib.Format.formatter -> Outcometree.out_module_type -> unit) refval print_out_type_extension :
+ (Stdlib.Format.formatter -> Outcometree.out_type_extension -> unit) refval print_out_sig_item :
+ (Stdlib.Format.formatter -> Outcometree.out_sig_item -> unit) refval print_out_signature :
+ (Stdlib.Format.formatter -> Outcometree.out_sig_item list -> unit) refval print_out_phrase :
+ (Stdlib.Format.formatter -> Outcometree.out_phrase -> unit) refval read_interactive_input : (string -> bytes -> int -> int * bool) refval toplevel_startup_hook : (unit -> unit) refval add_hook : (event -> unit) -> unitval run_hooks : event -> unitval may_trace : bool refTopmainTopstartTracetype traced_function = {path : Path.t;closure : Stdlib.Obj.t;actual_code : codeptr;instrumented_fun : codeptr -> Stdlib.Obj.t -> Stdlib.Obj.t -> Stdlib.Obj.t;}val traced_functions : traced_function list refval is_traced : Stdlib.Obj.t -> Path.t optionval get_code_pointer : Stdlib.Obj.t -> codeptrval set_code_pointer : Stdlib.Obj.t -> codeptr -> unitval instrument_closure :
+ Env.t ->
+ Longident.t ->
+ Stdlib.Format.formatter ->
+ Types.type_expr ->
+ codeptr ->
+ Stdlib.Obj.t ->
+ Stdlib.Obj.t ->
+ Stdlib.Obj.tval print_trace : Stdlib.Obj.t -> Stdlib.Obj.t -> Stdlib.Obj.tTranslattributeval check_attribute : Typedtree.expression -> Parsetree.attribute -> unitval check_attribute_on_module :
+ Typedtree.module_expr ->
+ Parsetree.attribute ->
+ unitval add_inline_attribute :
+ Lambda.lambda ->
+ Location.t ->
+ Parsetree.attributes ->
+ Lambda.lambdaval get_inline_attribute : Parsetree.attributes -> Lambda.inline_attributeval add_specialise_attribute :
+ Lambda.lambda ->
+ Location.t ->
+ Parsetree.attributes ->
+ Lambda.lambdaval get_specialise_attribute :
+ Parsetree.attributes ->
+ Lambda.specialise_attributeval add_local_attribute :
+ Lambda.lambda ->
+ Location.t ->
+ Parsetree.attributes ->
+ Lambda.lambdaval get_local_attribute : Parsetree.attributes -> Lambda.local_attributeval get_and_remove_inlined_attribute :
+ Typedtree.expression ->
+ Lambda.inline_attribute * Typedtree.expressionval get_and_remove_inlined_attribute_on_module :
+ Typedtree.module_expr ->
+ Lambda.inline_attribute * Typedtree.module_exprval get_and_remove_specialised_attribute :
+ Typedtree.expression ->
+ Lambda.specialise_attribute * Typedtree.expressionval get_tailcall_attribute :
+ Typedtree.expression ->
+ Lambda.tailcall_attribute * Typedtree.expressionval add_function_attributes :
+ Lambda.lambda ->
+ Location.t ->
+ Parsetree.attributes ->
+ Lambda.lambdaTranslclassval transl_class :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Ident.t list ->
+ Ident.t ->
+ string list ->
+ Typedtree.class_expr ->
+ Asttypes.virtual_flag ->
+ Lambda.lambdaexception Error of Location.t * errorval report_error : Stdlib.Format.formatter -> error -> unitTranslcoreval pure_module : Typedtree.module_expr -> Lambda.let_kindval transl_exp :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Typedtree.expression ->
+ Lambda.lambdaval transl_apply :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ ?tailcall:Lambda.tailcall_attribute ->
+ ?inlined:Lambda.inline_attribute ->
+ ?specialised:Lambda.specialise_attribute ->
+ Lambda.lambda ->
+ (Asttypes.arg_label * Typedtree.expression option) list ->
+ Lambda.scoped_location ->
+ Lambda.lambdaval transl_let :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ ?in_structure:bool ->
+ Asttypes.rec_flag ->
+ Typedtree.value_binding list ->
+ Lambda.lambda ->
+ Lambda.lambdaval transl_extension_constructor :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Env.t ->
+ Path.t option ->
+ Typedtree.extension_constructor ->
+ Lambda.lambdaval transl_scoped_exp :
+ scopes:Debuginfo.Scoped_location.scopes ->
+ Typedtree.expression ->
+ Lambda.lambdaexception Error of Location.t * errorval report_error : Stdlib.Format.formatter -> error -> unitval transl_module :
+ (scopes:Debuginfo.Scoped_location.scopes ->
+ Typedtree.module_coercion ->
+ Path.t option ->
+ Typedtree.module_expr ->
+ Lambda.lambda)
+ refval transl_object :
+ (scopes:Debuginfo.Scoped_location.scopes ->
+ Ident.t ->
+ string list ->
+ Typedtree.class_expr ->
+ Lambda.lambda)
+ refTranslmodval transl_implementation :
+ string ->
+ (Typedtree.structure * Typedtree.module_coercion) ->
+ Lambda.programval transl_store_phrases : string -> Typedtree.structure -> int * Lambda.lambdaval transl_store_implementation :
+ string ->
+ (Typedtree.structure * Typedtree.module_coercion) ->
+ Lambda.programval transl_implementation_flambda :
+ string ->
+ (Typedtree.structure * Typedtree.module_coercion) ->
+ Lambda.programval transl_toplevel_definition : Typedtree.structure -> Lambda.lambdaval transl_package :
+ Ident.t option list ->
+ Ident.t ->
+ Typedtree.module_coercion ->
+ Lambda.lambdaval transl_store_package :
+ Ident.t option list ->
+ Ident.t ->
+ Typedtree.module_coercion ->
+ int * Lambda.lambdaval transl_package_flambda :
+ Ident.t option list ->
+ Typedtree.module_coercion ->
+ int * Lambda.lambdaval toplevel_name : Ident.t -> stringval primitive_declarations : Primitive.description list reftype unsafe_info = | Unsafe of {reason : unsafe_component;loc : Location.t;subid : Ident.t;}| Unnamedexception Error of Location.t * errorval report_error : Location.t -> error -> Location.errorTranslobjval oo_prim : string -> Lambda.lambdaval meth : Lambda.lambda -> string -> Lambda.lambda * Lambda.lambda listval transl_label_init : (unit -> Lambda.lambda * 'a) -> Lambda.lambda * 'aval transl_store_label_init :
+ Ident.t ->
+ int ->
+ ('a -> Lambda.lambda) ->
+ 'a ->
+ int * Lambda.lambdaval method_ids : Ident.Set.t refval oo_wrap : Env.t -> bool -> ('a -> Lambda.lambda) -> 'a -> Lambda.lambdaTranslprimval event_before :
+ Lambda.scoped_location ->
+ Typedtree.expression ->
+ Lambda.lambda ->
+ Lambda.lambdaval event_after :
+ Lambda.scoped_location ->
+ Typedtree.expression ->
+ Lambda.lambda ->
+ Lambda.lambdaval add_exception_ident : Ident.t -> unitval remove_exception_ident : Ident.t -> unitval get_used_primitives : unit -> Path.t listval check_primitive_arity : Location.t -> Primitive.description -> unitval transl_primitive :
+ Lambda.scoped_location ->
+ Primitive.description ->
+ Env.t ->
+ Types.type_expr ->
+ Path.t option ->
+ Lambda.lambdaval transl_primitive_application :
+ Lambda.scoped_location ->
+ Primitive.description ->
+ Env.t ->
+ Types.type_expr ->
+ Path.t ->
+ Typedtree.expression option ->
+ Lambda.lambda list ->
+ Typedtree.expression list ->
+ Lambda.lambdaexception Error of Location.t * errorval report_error : Stdlib.Format.formatter -> error -> unitTraverse_for_exported_symbolstype symbols_to_export = {symbols : Symbol.Set.t;export_ids : Export_id.Set.t;set_of_closure_ids : Set_of_closures_id.Set.t;set_of_closure_ids_keep_declaration : Set_of_closures_id.Set.t;relevant_imported_closure_ids : Closure_id.Set.t;relevant_local_closure_ids : Closure_id.Set.t;relevant_imported_vars_within_closure : Var_within_closure.Set.t;relevant_local_vars_within_closure : Var_within_closure.Set.t;}val traverse :
+ sets_of_closures_map:Flambda.set_of_closures Set_of_closures_id.Map.t ->
+ closure_id_to_set_of_closures_id:Set_of_closures_id.t Closure_id.Map.t ->
+ function_declarations_map:
+ Simple_value_approx.function_declarations Set_of_closures_id.Map.t ->
+ values:Export_info.descr Export_id.Map.t ->
+ symbol_id:Export_id.t Symbol.Map.t ->
+ root_symbol:Symbol.t ->
+ symbols_to_exportComputes the transitive closure in Symbol.t, Closure_id.t and Set_of_closures_id.t and determines which ones of those should be exported (i.e: included in the cmx files). *
Type_immediacy.ViolationType_immediacyImmediacy status of a type
module Violation : sig ... endval coerce : t -> as_:t -> (unit, Violation.t) resultcoerce t ~as_ returns Ok () iff t can be seen as type immediacy as_. For instance, Always can be seen as Always_on_64bits but the opposite is not true. Return Error _ if the coercion is not possible.
val of_attributes : Parsetree.attributes -> tReturn the immediateness of a type as indicated by the user via attributes
Typeclasstype 'a class_info = {cls_id : Ident.t;cls_id_loc : string Asttypes.loc;cls_decl : Types.class_declaration;cls_ty_id : Ident.t;cls_ty_decl : Types.class_type_declaration;cls_obj_id : Ident.t;cls_obj_abbr : Types.type_declaration;cls_typesharp_id : Ident.t;cls_abbr : Types.type_declaration;cls_arity : int;cls_pub_methods : string list;cls_info : 'a;}type class_type_info = {clsty_ty_id : Ident.t;clsty_id_loc : string Asttypes.loc;clsty_ty_decl : Types.class_type_declaration;clsty_obj_id : Ident.t;clsty_obj_abbr : Types.type_declaration;clsty_typesharp_id : Ident.t;clsty_abbr : Types.type_declaration;clsty_info : Typedtree.class_type_declaration;}val class_declarations :
+ Env.t ->
+ Parsetree.class_declaration list ->
+ Typedtree.class_declaration class_info list * Env.tval class_descriptions :
+ Env.t ->
+ Parsetree.class_description list ->
+ Typedtree.class_description class_info list * Env.tval class_type_declarations :
+ Env.t ->
+ Parsetree.class_description list ->
+ class_type_info list * Env.tval approx_class_declarations :
+ Env.t ->
+ Parsetree.class_description list ->
+ class_type_info listtype error = | Unconsistent_constraint of Errortrace.unification_error| Field_type_mismatch of string * string * Errortrace.unification_error| Unexpected_field of Types.type_expr * string| Structure_expected of Types.class_type| Cannot_apply of Types.class_type| Apply_wrong_label of Asttypes.arg_label| Pattern_type_clash of Types.type_expr| Repeated_parameter| Unbound_class_2 of Longident.t| Unbound_class_type_2 of Longident.t| Abbrev_type_clash of Types.type_expr * Types.type_expr * Types.type_expr| Constructor_type_mismatch of string * Errortrace.unification_error| Virtual_class of kind * string list * string list| Undeclared_methods of kind * string list| Parameter_arity_mismatch of Longident.t * int * int| Parameter_mismatch of Errortrace.unification_error| Bad_parameters of Ident.t * Types.type_expr * Types.type_expr| Class_match_failure of Ctype.class_match_failure list| Unbound_val of string| Unbound_type_var of Stdlib.Format.formatter ->
+ unit
+ * Types.type_expr * bool * string * Types.type_expr| Non_generalizable_class of Ident.t * Types.class_declaration| Cannot_coerce_self of Types.type_expr| Non_collapsable_conjunction of Ident.t
+ * Types.class_declaration
+ * Errortrace.unification_error| Self_clash of Errortrace.unification_error| Mutability_mismatch of string * Asttypes.mutable_flag| No_overriding of string * string| Duplicate of string * string| Closing_self_type of Types.class_signatureexception Error of Location.t * Env.t * errorexception Error_forward of Location.errorval report_error : Env.t -> Stdlib.Format.formatter -> error -> unitval type_open_descr :
+ (?used_slot:bool ref ->
+ Env.t ->
+ Parsetree.open_description ->
+ Typedtree.open_description * Env.t)
+ refTypecore.Datatype_kindTypecoretype pattern_variable = {pv_id : Ident.t;pv_type : Types.type_expr;pv_loc : Location.t;pv_as_var : bool;pv_attributes : Typedtree.attributes;}val mk_expected :
+ ?explanation:type_forcing_context ->
+ Types.type_expr ->
+ type_expectedval is_nonexpansive : Typedtree.expression -> boolmodule Datatype_kind : sig ... endtype wrong_name = {type_path : Path.t;kind : Datatype_kind.t;name : string Asttypes.loc;valid_names : string list;}type existential_restriction = | At_toplevelno existential types at the toplevel
*)| In_groupnor with let ... and ...
| In_recor recursive definition
*)| With_attributesor let[@any_attribute] = ...
| In_class_argsor in class arguments class c (...) = ...
| In_class_defor in class c = let ... in ...
| In_self_patternor in self pattern
*)val type_binding :
+ Env.t ->
+ Asttypes.rec_flag ->
+ Parsetree.value_binding list ->
+ Typedtree.value_binding list * Env.tval type_let :
+ existential_restriction ->
+ Env.t ->
+ Asttypes.rec_flag ->
+ Parsetree.value_binding list ->
+ Typedtree.value_binding list * Env.tval type_expression : Env.t -> Parsetree.expression -> Typedtree.expressionval type_class_arg_pattern :
+ string ->
+ Env.t ->
+ Env.t ->
+ Asttypes.arg_label ->
+ Parsetree.pattern ->
+ Typedtree.pattern
+ * (Ident.t * Ident.t * Types.type_expr) list
+ * Env.t
+ * Env.tval type_self_pattern :
+ Env.t ->
+ Parsetree.pattern ->
+ Typedtree.pattern * pattern_variable listval check_partial :
+ ?lev:int ->
+ Env.t ->
+ Types.type_expr ->
+ Location.t ->
+ Typedtree.value Typedtree.case list ->
+ Typedtree.partialval type_expect :
+ ?in_function:(Location.t * Types.type_expr) ->
+ Env.t ->
+ Parsetree.expression ->
+ type_expected ->
+ Typedtree.expressionval type_exp : Env.t -> Parsetree.expression -> Typedtree.expressionval type_approx : Env.t -> Parsetree.expression -> Types.type_exprval type_argument :
+ Env.t ->
+ Parsetree.expression ->
+ Types.type_expr ->
+ Types.type_expr ->
+ Typedtree.expressionval option_some : Env.t -> Typedtree.expression -> Typedtree.expressionval option_none :
+ Env.t ->
+ Types.type_expr ->
+ Location.t ->
+ Typedtree.expressionval extract_option_type : Env.t -> Types.type_expr -> Types.type_exprval generalizable : int -> Types.type_expr -> boolval name_pattern : string -> Typedtree.pattern list -> Ident.tval name_cases : string -> Typedtree.value Typedtree.case list -> Ident.tval self_coercion : (Path.t * Location.t list ref) list reftype error = | Constructor_arity_mismatch of Longident.t * int * int| Label_mismatch of Longident.t * Errortrace.unification_error| Pattern_type_clash : Errortrace.unification_error
+ * _ Typedtree.pattern_desc option -> error| Or_pattern_type_clash of Ident.t * Errortrace.unification_error| Multiply_bound_variable of string| Orpat_vars of Ident.t * Ident.t list| Expr_type_clash of Errortrace.unification_error
+ * type_forcing_context option
+ * Typedtree.expression_desc option| Apply_non_function of Types.type_expr| Apply_wrong_label of Asttypes.arg_label * Types.type_expr * bool| Label_multiply_defined of string| Label_missing of Ident.t list| Label_not_mutable of Longident.t| Wrong_name of string * type_expected * wrong_name| Name_type_mismatch of Datatype_kind.t
+ * Longident.t
+ * Path.t * Path.t
+ * (Path.t * Path.t) list| Invalid_format of string| Not_an_object of Types.type_expr * type_forcing_context option| Undefined_method of Types.type_expr * string * string list option| Undefined_self_method of string * string list| Virtual_class of Longident.t| Private_type of Types.type_expr| Private_label of Longident.t * Types.type_expr| Private_constructor of Types.constructor_description * Types.type_expr| Unbound_instance_variable of string * string list| Instance_variable_not_mutable of string| Not_subtype of Errortrace.Subtype.error| Outside_class| Value_multiply_overridden of string| Coercion_failure of Errortrace.expanded_type
+ * Errortrace.unification_error
+ * bool| Not_a_function of Types.type_expr * type_forcing_context option| Too_many_arguments of Types.type_expr * type_forcing_context option| Abstract_wrong_label of {got : Asttypes.arg_label;expected : Asttypes.arg_label;expected_type : Types.type_expr;explanation : type_forcing_context option;}| Scoping_let_module of string * Types.type_expr| Not_a_polymorphic_variant_type of Longident.t| Incoherent_label_order| Less_general of string * Errortrace.unification_error| Modules_not_allowed| Cannot_infer_signature| Not_a_packed_module of Types.type_expr| Unexpected_existential of existential_restriction * string * string list| Invalid_interval| Invalid_for_loop_index| No_value_clauses| Exception_pattern_disallowed| Mixed_value_and_exception_patterns_under_guard| Inlined_record_escape| Inlined_record_expected| Unrefuted_pattern of Typedtree.pattern| Invalid_extension_constructor_payload| Not_an_extension_constructor| Literal_overflow of string| Unknown_literal of string * char| Illegal_letrec_pat| Illegal_letrec_expr| Illegal_class_expr| Letop_type_clash of string * Errortrace.unification_error| Andop_type_clash of string * Errortrace.unification_error| Bindings_type_clash of Errortrace.unification_error| Unbound_existential of Ident.t list * Types.type_expr| Missing_type_constraint| Wrong_expected_kind of wrong_kind_sort * wrong_kind_context * Types.type_expr| Expr_not_a_record_type of Types.type_exprexception Error of Location.t * Env.t * errorexception Error_forward of Location.errorval report_error : loc:Location.t -> Env.t -> error -> Location.errorval type_module :
+ (Env.t -> Parsetree.module_expr -> Typedtree.module_expr * Shape.t) refval type_open :
+ (?used_slot:bool ref ->
+ Asttypes.override_flag ->
+ Env.t ->
+ Location.t ->
+ Longident.t Asttypes.loc ->
+ Path.t * Env.t)
+ refval type_open_decl :
+ (?used_slot:bool ref ->
+ Env.t ->
+ Parsetree.open_declaration ->
+ Typedtree.open_declaration * Types.signature * Env.t)
+ refval type_object :
+ (Env.t ->
+ Location.t ->
+ Parsetree.class_structure ->
+ Typedtree.class_structure * string list)
+ refval type_package :
+ (Env.t ->
+ Parsetree.module_expr ->
+ Path.t ->
+ (Longident.t * Types.type_expr) list ->
+ Typedtree.module_expr * (Longident.t * Types.type_expr) list)
+ refval constant : Parsetree.constant -> (Asttypes.constant, error) resultval check_recursive_bindings : Env.t -> Typedtree.value_binding list -> unitval check_recursive_class_bindings :
+ Env.t ->
+ Ident.t list ->
+ Typedtree.class_expr list ->
+ unitTypedeclval transl_type_decl :
+ Env.t ->
+ Asttypes.rec_flag ->
+ Parsetree.type_declaration list ->
+ Typedtree.type_declaration list * Env.tval transl_exception :
+ Env.t ->
+ Parsetree.extension_constructor ->
+ Typedtree.extension_constructor * Env.tval transl_type_exception :
+ Env.t ->
+ Parsetree.type_exception ->
+ Typedtree.type_exception * Env.tval transl_type_extension :
+ bool ->
+ Env.t ->
+ Location.t ->
+ Parsetree.type_extension ->
+ Typedtree.type_extension * Env.tval transl_value_decl :
+ Env.t ->
+ Location.t ->
+ Parsetree.value_description ->
+ Typedtree.value_description * Env.tval transl_with_constraint :
+ Ident.t ->
+ ?fixed_row_path:Path.t ->
+ sig_env:Env.t ->
+ sig_decl:Types.type_declaration ->
+ outer_env:Env.t ->
+ Parsetree.type_declaration ->
+ Typedtree.type_declarationval abstract_type_decl : injective:bool -> int -> Types.type_declarationval approx_type_decl :
+ Parsetree.type_declaration list ->
+ (Ident.t * Types.type_declaration) listval check_recmod_typedecl :
+ Env.t ->
+ Location.t ->
+ Ident.t list ->
+ Path.t ->
+ Types.type_declaration ->
+ unitval check_coherence :
+ Env.t ->
+ Location.t ->
+ Path.t ->
+ Types.type_declaration ->
+ unitval is_fixed_type : Parsetree.type_declaration -> booltype error = | Repeated_parameter| Duplicate_constructor of string| Too_many_constructors| Duplicate_label of string| Recursive_abbrev of string| Cycle_in_def of string * Types.type_expr| Definition_mismatch of Types.type_expr
+ * Env.t
+ * Includecore.type_mismatch option| Constraint_failed of Env.t * Errortrace.unification_error| Inconsistent_constraint of Env.t * Errortrace.unification_error| Type_clash of Env.t * Errortrace.unification_error| Non_regular of {definition : Path.t;used_as : Types.type_expr;defined_as : Types.type_expr;expansions : (Types.type_expr * Types.type_expr) list;}| Null_arity_external| Missing_native_external| Unbound_type_var of Types.type_expr * Types.type_declaration| Cannot_extend_private_type of Path.t| Not_extensible_type of Path.t| Extension_mismatch of Path.t * Env.t * Includecore.type_mismatch| Rebind_wrong_type of Longident.t * Env.t * Errortrace.unification_error| Rebind_mismatch of Longident.t * Path.t * Path.t| Rebind_private of Longident.t| Variance of Typedecl_variance.error| Unbound_type_var_ext of Types.type_expr * Types.extension_constructor| Val_in_structure| Multiple_native_repr_attributes| Cannot_unbox_or_untag_type of native_repr_kind| Deep_unbox_or_untag_attribute of native_repr_kind| Immediacy of Typedecl_immediacy.error| Separability of Typedecl_separability.error| Bad_unboxed_attribute of string| Boxed_and_unboxed| Nonrec_gadt| Invalid_private_row_declaration of Types.type_exprexception Error of Location.t * errorval report_error : Stdlib.Format.formatter -> error -> unitTypedecl_immediacyexception Error of Location.t * errorval compute_decl : Env.t -> Types.type_declaration -> Type_immediacy.tval property : (Type_immediacy.t, unit) Typedecl_properties.propertyval update_decls :
+ Env.t ->
+ (Ident.t * Typedecl_properties.decl) list ->
+ (Ident.t * Typedecl_properties.decl) listTypedecl_propertiestype decl = Types.type_declarationAn abstract interface for properties of type definitions, such as variance and immediacy, that are computed by a fixpoint on mutually-recursive type declarations. This interface contains all the operations needed to initialize and run the fixpoint computation, and then (optionally) check that the result is consistent with the declaration or user expectations.
type ('prop, 'req) property = {eq : 'prop -> 'prop -> bool;merge : prop:'prop -> new_prop:'prop -> 'prop;default : decl -> 'prop;compute : Env.t -> decl -> 'req -> 'prop;update_decl : decl -> 'prop -> decl;check : Env.t -> Ident.t -> decl -> 'req -> unit;}'prop represents the type of property values (Types.Variance.t, just 'bool' for immediacy, etc).
'req represents the property value required by the author of the declaration, if they gave an expectation: type +'a t = ....
Some properties have no natural notion of user requirement, or their requirement is global, or already stored in type_declaration; they can just use unit as 'req parameter.
val compute_property :
+ ('prop, 'req) property ->
+ Env.t ->
+ (Ident.t * decl) list ->
+ 'req list ->
+ (Ident.t * decl) listcompute_property prop env decls req performs a fixpoint computation to determine the final values of a property on a set of mutually-recursive type declarations. The req argument must be a list of the same size as decls, providing the user requirement for each declaration.
Typedecl_separabilityThe OCaml runtime assumes for type-directed optimizations that all types are "separable". A type is "separable" if either all its inhabitants (the values of this type) are floating-point numbers, or none of them are.
(Note: This assumption is required for the dynamic float array optimization; it is only made if Config.flat_float_array is set, otherwise the code in this module becomes trivial -- see compute_decl.)
This soundness requirement could be broken by type declarations mixing existentials and the "@@unboxed" annotation. Consider the declaration
type any = Any : 'a -> any [@@unboxed]which corresponds to the existential type "exists a. a". If this type is allowed to be unboxed, then it is inhabited by both float values and non-float values. On the contrary, if unboxing is disallowed, the inhabitants are all blocks with the Any constructors pointing to its parameter: they may point to a float, but they are not floats.
The present module contains a static analysis ensuring that declarations annotated with "@@unboxed" can be safely unboxed. The idea is to check the "separability" (in the above sense) of the argument type that would be unboxed, and reject the unboxed declaration if it would create a non-separable type.
Checking mutually-recursive type declarations is a bit subtle. Consider, for example, the following declarations.
type foo = Foo : 'a t -> foo [@@unboxed]
+and 'a t = ...Deciding whether the type foo should be accepted requires inspecting the declaration of 'a t, which may itself refer to foo in turn. In general, the analysis performs a fixpoint computation. It is somewhat similar to what is done for inferring the variance of type parameters.
Our analysis is defined using inference rules for our judgment Def; Gamma |- t : m, in which a type expression t is checked against a "mode" m. This "mode" describes the separability requirement on the type expression (see below for more details). The mode Gamma maps type variables to modes and Def records the "mode signature" of the mutually-recursive type declarations that are being checked.
The "mode signature" of a type with parameters ('a, 'b) t is of the form ('a : m1, 'b : m2) t, where m1 and m2 are modes. Its meaning is the following: a concrete instance (foo, bar) t of the type is separable if foo has mode m1 and bar has mode m2.
exception Error of Location.t * errorException raised when a type declaration is not separable, or when its separability cannot be established.
type mode = Types.Separability.t = | Ind| Sep| DeepsepThe mode Sep ("separable") characterizes types that are indeed separable: either they only contain floating-point values, or none of the values at this type are floating-point values. On a type parameter, it indicates that this parameter must be separable for the whole type definition to be separable. For example, the mode signature for the type declaration type 'a
+ t = 'a is ('a : Sep) t. For the right-hand side to be separable, the parameter 'a must be separable.
The mode Ind ("indifferent") characterizes any type -- separable or not. On a type parameter, it indicates that this parameter needs not be separable for the whole type definition to be separable. For example, type 'a t = 'a * bool does not require its parameter 'a to be separable as 'a * bool can never contain float values. Its mode signature is thus ('a : Ind) t.
Finally, the mode Deepsep ("deeply separable") characterizes types that are separable, and whose type sub-expressions are also separable. This advanced feature is only used in the presence of constraints. For example, type 'a t = 'b constraint 'a = 'b * bool may not be separable even if 'a is (its separately depends on 'b, a fragment of 'a), so its mode signature is ('a : Deepsep) t.
The different modes are ordered as Ind < Sep < Deepsep (from the least demanding to the most demanding).
val compute_decl : Env.t -> Types.type_declaration -> mode listcompute_decl env def returns the signature required for the type definition def in the typing environment env -- including signatures for the current recursive block.
The Error exception is raised if no such signature exists -- the definition will always be invalid. This only happens when the definition is marked to be unboxed.
Variant (or record) declarations that are not marked with the "@@unboxed" annotation, including those that contain several variants (or labels), are always separable. In particular, their mode signatures do not require anything of their type parameters, which are marked Ind.
Finally, if Config.flat_float_array is not set, then separability is not required anymore; we just use Ind as the mode of each parameter without any check.
type prop = Types.Separability.signatureProperty interface (see Typedecl_properties). These functions rely on compute_decl and raise the Error exception on error.
val property : (prop, unit) Typedecl_properties.propertyval update_decls :
+ Env.t ->
+ (Ident.t * Typedecl_properties.decl) list ->
+ (Ident.t * Typedecl_properties.decl) listTypedecl_unboxedval get_unboxed_type_representation :
+ Env.t ->
+ Types.type_expr ->
+ Types.type_expr optionTypedecl_varianceval variance_of_params :
+ (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list ->
+ surface_variance listval variance_of_sdecl : Parsetree.type_declaration -> surface_variance listtype prop = Types.Variance.t listtype req = surface_variance listval property : (Types.Variance.t list, req) Typedecl_properties.propertytype error = | Bad_variance of variance_error * surface_variance * surface_variance| Varying_anonymousexception Error of Location.t * errorval check_variance_extension :
+ Env.t ->
+ Types.type_declaration ->
+ Typedtree.extension_constructor ->
+ (req * Location.t) ->
+ unitval compute_decl : Env.t -> check:bool -> Types.type_declaration -> req -> propval update_decls :
+ Env.t ->
+ Parsetree.type_declaration list ->
+ (Ident.t * Types.type_declaration) list ->
+ (Ident.t * Types.type_declaration) listval update_class_decls :
+ Env.t ->
+ (Ident.t
+ * Typedecl_properties.decl
+ * Types.type_declaration
+ * Types.class_declaration
+ * Types.class_type_declaration
+ * 'a Typedtree.class_infos)
+ list ->
+ (Typedecl_properties.decl
+ * Types.type_declaration
+ * Types.class_declaration
+ * Types.class_type_declaration)
+ listTypedtreeAbstract syntax tree after typing
By comparison with Parsetree:
Longindent.t is accompanied by a resolved Path.t.type attribute = Parsetree.attributetype attributes = attribute listtype _ pattern_category = | Value : value pattern_category| Computation : computation pattern_categorytype pattern = value general_patternand 'k general_pattern = 'k pattern_desc pattern_dataand 'a pattern_data = {pat_desc : 'a;pat_loc : Location.t;pat_extra : (pat_extra * Location.t * attributes) list;pat_type : Types.type_expr;pat_env : Env.t;pat_attributes : attributes;}and pat_extra = | Tpat_constraint of core_typeP : T pat_desc = P
+ ; pat_extra = (Tpat_constraint T, _, _) :: ...
| Tpat_type of Path.t * Longident.t Asttypes.loc#tconst pat_desc = disjunction
+ ; pat_extra = (Tpat_type (P, "tconst"), _, _) :: ...
where disjunction is a Tpat_or _ representing the branches of tconst.
| Tpat_open of Path.t * Longident.t Asttypes.loc * Env.t| Tpat_unpack(module P) pat_desc = Tpat_var "P"
+ ; pat_extra = (Tpat_unpack, _, _) :: ...
and 'k pattern_desc = | Tpat_any : value pattern_desc_
*)| Tpat_var : Ident.t * string Asttypes.loc -> value pattern_descx
*)| Tpat_alias : value general_pattern
+ * Ident.t
+ * string Asttypes.loc -> value pattern_descP as a
*)| Tpat_constant : Asttypes.constant -> value pattern_desc1, 'a', "true", 1.0, 1l, 1L, 1n
*)| Tpat_tuple : value general_pattern list -> value pattern_desc(P1, ..., Pn)
Invariant: n >= 2
*)| Tpat_construct : Longident.t Asttypes.loc
+ * Types.constructor_description
+ * value general_pattern list
+ * (Ident.t Asttypes.loc list * core_type) option -> value pattern_descC (, None) C P (P, None) C (P1, ..., Pn) (P1; ...; Pn, None) C (P : t) (P, Some (, t)) C (P1, ..., Pn : t) (P1; ...; Pn, Some (, t)) C (type a) (P : t) (P, Some (a, t)) C (type a) (P1, ..., Pn : t) (P1; ...; Pn, Some (a, t))
| Tpat_variant : Asttypes.label
+ * value general_pattern option
+ * Types.row_desc ref -> value pattern_desc| Tpat_record : (Longident.t Asttypes.loc
+ * Types.label_description
+ * value general_pattern)
+ list
+ * Asttypes.closed_flag -> value pattern_desc l1=P1; ...; ln=Pn (flag = Closed) l1=P1; ...; ln=Pn; _ (flag = Open)
Invariant: n > 0
*)| Tpat_array : value general_pattern list -> value pattern_desc| P1; ...; Pn |
| Tpat_lazy : value general_pattern -> value pattern_desclazy P
*)| Tpat_value : tpat_value_argument -> computation pattern_descP
Invariant: Tpat_value pattern should not carry pat_attributes or pat_extra metadata coming from user syntax, which must be on the inner pattern node -- to facilitate searching for a certain value pattern constructor with a specific attributed.
To enforce this restriction, we made the argument of the Tpat_value constructor a private synonym of pattern, requiring you to use the as_computation_pattern function below instead of using the Tpat_value constructor directly.
| Tpat_exception : value general_pattern -> computation pattern_descexception P
*)| Tpat_or : 'k general_pattern
+ * 'k general_pattern
+ * Types.row_desc option -> 'k pattern_descP1 | P2
row_desc = Some _ when translating Ppat_type _, None otherwise.
and tpat_value_argument = private value general_patternand expression = {exp_desc : expression_desc;exp_loc : Location.t;exp_extra : (exp_extra * Location.t * attributes) list;exp_type : Types.type_expr;exp_env : Env.t;exp_attributes : attributes;}and expression_desc = | Texp_ident of Path.t * Longident.t Asttypes.loc * Types.value_descriptionx M.x
*)| Texp_constant of Asttypes.constant1, 'a', "true", 1.0, 1l, 1L, 1n
*)| Texp_let of Asttypes.rec_flag * value_binding list * expressionlet P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive) let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)
*)| Texp_function of {arg_label : Asttypes.arg_label;param : Ident.t;cases : value case list;partial : partial;}Pexp_fun and Pexp_function both translate to Texp_function. See Parsetree for more details.
param is the identifier that is to be used to name the parameter of the function.
partial = Partial if the pattern match is partial Total otherwise.
| Texp_apply of expression * (Asttypes.arg_label * expression option) listE0 ~l1:E1 ... ~ln:En
The expression can be None if the expression is abstracted over this argument. It currently appears when a label is applied.
For example: let f x ~y = x + y in f ~y:3
The resulting typedtree for the application is: Texp_apply (Texp_ident "f/1037", (Nolabel, None);
+ (Labelled "y", Some (Texp_constant Const_int 3))
+ )
| Texp_match of expression * computation case list * partialmatch E0 with | P1 -> E1 | P2 | exception P3 -> E2 | exception P4 -> E3
Texp_match (E0, [(P1, E1); (P2 | exception P3, E2);
+ (exception P4, E3)], _)
| Texp_try of expression * value case listtry E with P1 -> E1 | ... | PN -> EN
*)| Texp_tuple of expression list(E1, ..., EN)
*)| Texp_construct of Longident.t Asttypes.loc
+ * Types.constructor_description
+ * expression listC C E E C (E1, ..., En) E1;...;En
| Texp_variant of Asttypes.label * expression option| Texp_record of {fields : (Types.label_description * record_label_definition) array;representation : Types.record_representation;extended_expression : expression option;} l1=P1; ...; ln=Pn (extended_expression = None) E0 with l1=P1; ...; ln=Pn (extended_expression = Some E0)
Invariant: n > 0
If the type is l1: t1; l2: t2 , the expression E0 with t2=P2 is represented as Texp_record fields = [| l1, Kept t1; l2 Override P2 |]; representation;
+ extended_expression = Some E0
| Texp_field of expression * Longident.t Asttypes.loc * Types.label_description| Texp_setfield of expression
+ * Longident.t Asttypes.loc
+ * Types.label_description
+ * expression| Texp_array of expression list| Texp_ifthenelse of expression * expression * expression option| Texp_sequence of expression * expression| Texp_while of expression * expression| Texp_for of Ident.t
+ * Parsetree.pattern
+ * expression
+ * expression
+ * Asttypes.direction_flag
+ * expression| Texp_send of expression * meth| Texp_new of Path.t * Longident.t Asttypes.loc * Types.class_declaration| Texp_instvar of Path.t * Path.t * string Asttypes.loc| Texp_setinstvar of Path.t * Path.t * string Asttypes.loc * expression| Texp_override of Path.t * (Ident.t * string Asttypes.loc * expression) list| Texp_letmodule of Ident.t option
+ * string option Asttypes.loc
+ * Types.module_presence
+ * module_expr
+ * expression| Texp_letexception of extension_constructor * expression| Texp_assert of expression| Texp_lazy of expression| Texp_object of class_structure * string list| Texp_pack of module_expr| Texp_letop of {let_ : binding_op;ands : binding_op list;param : Ident.t;body : value case;partial : partial;}| Texp_unreachable| Texp_extension_constructor of Longident.t Asttypes.loc * Path.t| Texp_open of open_declaration * expressionlet open! M in e
and record_label_definition = | Kept of Types.type_expr| Overridden of Longident.t Asttypes.loc * expressionand binding_op = {bop_op_path : Path.t;bop_op_name : string Asttypes.loc;bop_op_val : Types.value_description;bop_op_type : Types.type_expr;bop_exp : expression;bop_loc : Location.t;}and class_expr = {cl_desc : class_expr_desc;cl_loc : Location.t;cl_type : Types.class_type;cl_env : Env.t;cl_attributes : attributes;}and class_expr_desc = | Tcl_ident of Path.t * Longident.t Asttypes.loc * core_type list| Tcl_structure of class_structure| Tcl_fun of Asttypes.arg_label
+ * pattern
+ * (Ident.t * expression) list
+ * class_expr
+ * partial| Tcl_apply of class_expr * (Asttypes.arg_label * expression option) list| Tcl_let of Asttypes.rec_flag
+ * value_binding list
+ * (Ident.t * expression) list
+ * class_expr| Tcl_constraint of class_expr
+ * class_type option
+ * string list
+ * string list
+ * Types.MethSet.t| Tcl_open of open_description * class_exprand class_structure = {cstr_self : pattern;cstr_fields : class_field list;cstr_type : Types.class_signature;cstr_meths : Ident.t Types.Meths.t;}and class_field_kind = | Tcfk_virtual of core_type| Tcfk_concrete of Asttypes.override_flag * expressionand class_field_desc = | Tcf_inherit of Asttypes.override_flag
+ * class_expr
+ * string option
+ * (string * Ident.t) list
+ * (string * Ident.t) list| Tcf_val of string Asttypes.loc
+ * Asttypes.mutable_flag
+ * Ident.t
+ * class_field_kind
+ * bool| Tcf_method of string Asttypes.loc * Asttypes.private_flag * class_field_kind| Tcf_constraint of core_type * core_type| Tcf_initializer of expression| Tcf_attribute of attributeand module_expr = {mod_desc : module_expr_desc;mod_loc : Location.t;mod_type : Types.module_type;mod_env : Env.t;mod_attributes : attributes;}and module_type_constraint = | Tmodtype_implicitThe module type constraint has been synthesized during typechecking.
*)| Tmodtype_explicit of module_typeThe module type was in the source file.
*)Annotations for Tmod_constraint.
and module_expr_desc = | Tmod_ident of Path.t * Longident.t Asttypes.loc| Tmod_structure of structure| Tmod_functor of functor_parameter * module_expr| Tmod_apply of module_expr * module_expr * module_coercion| Tmod_constraint of module_expr
+ * Types.module_type
+ * module_type_constraint
+ * module_coercionME (constraint = Tmodtype_implicit) (ME : MT) (constraint = Tmodtype_explicit MT)
*)| Tmod_unpack of expression * Types.module_typeand structure_item_desc = | Tstr_eval of expression * attributes| Tstr_value of Asttypes.rec_flag * value_binding list| Tstr_primitive of value_description| Tstr_type of Asttypes.rec_flag * type_declaration list| Tstr_typext of type_extension| Tstr_exception of type_exception| Tstr_module of module_binding| Tstr_recmodule of module_binding list| Tstr_modtype of module_type_declaration| Tstr_open of open_declaration| Tstr_class of (class_declaration * string list) list| Tstr_class_type of (Ident.t * string Asttypes.loc * class_type_declaration)
+ list| Tstr_include of include_declaration| Tstr_attribute of attributeand module_binding = {mb_id : Ident.t option;mb_name : string option Asttypes.loc;mb_presence : Types.module_presence;mb_expr : module_expr;mb_attributes : attributes;mb_loc : Location.t;}and value_binding = {vb_pat : pattern;vb_expr : expression;vb_attributes : attributes;vb_loc : Location.t;}and module_coercion = | Tcoerce_none| Tcoerce_structure of (int * module_coercion) list
+ * (Ident.t * int * module_coercion) list| Tcoerce_functor of module_coercion * module_coercion| Tcoerce_primitive of primitive_coercion| Tcoerce_alias of Env.t * Path.t * module_coercionand module_type = {mty_desc : module_type_desc;mty_type : Types.module_type;mty_env : Env.t;mty_loc : Location.t;mty_attributes : attributes;}and module_type_desc = | Tmty_ident of Path.t * Longident.t Asttypes.loc| Tmty_signature of signature| Tmty_functor of functor_parameter * module_type| Tmty_with of module_type
+ * (Path.t * Longident.t Asttypes.loc * with_constraint) list| Tmty_typeof of module_expr| Tmty_alias of Path.t * Longident.t Asttypes.locand primitive_coercion = {pc_desc : Primitive.description;pc_type : Types.type_expr;pc_env : Env.t;pc_loc : Location.t;}and signature_item_desc = | Tsig_value of value_description| Tsig_type of Asttypes.rec_flag * type_declaration list| Tsig_typesubst of type_declaration list| Tsig_typext of type_extension| Tsig_exception of type_exception| Tsig_module of module_declaration| Tsig_modsubst of module_substitution| Tsig_recmodule of module_declaration list| Tsig_modtype of module_type_declaration| Tsig_modtypesubst of module_type_declaration| Tsig_open of open_description| Tsig_include of include_description| Tsig_class of class_description list| Tsig_class_type of class_type_declaration list| Tsig_attribute of attributeand module_declaration = {md_id : Ident.t option;md_name : string option Asttypes.loc;md_presence : Types.module_presence;md_type : module_type;md_attributes : attributes;md_loc : Location.t;}and module_substitution = {ms_id : Ident.t;ms_name : string Asttypes.loc;ms_manifest : Path.t;ms_txt : Longident.t Asttypes.loc;ms_attributes : attributes;ms_loc : Location.t;}and module_type_declaration = {mtd_id : Ident.t;mtd_name : string Asttypes.loc;mtd_type : module_type option;mtd_attributes : attributes;mtd_loc : Location.t;}and 'a open_infos = {open_expr : 'a;open_bound_items : Types.signature;open_override : Asttypes.override_flag;open_env : Env.t;open_loc : Location.t;open_attributes : attribute list;}and open_description = (Path.t * Longident.t Asttypes.loc) open_infosand open_declaration = module_expr open_infosand 'a include_infos = {incl_mod : 'a;incl_type : Types.signature;incl_loc : Location.t;incl_attributes : attribute list;}and include_description = module_type include_infosand include_declaration = module_expr include_infosand with_constraint = | Twith_type of type_declaration| Twith_module of Path.t * Longident.t Asttypes.loc| Twith_modtype of module_type| Twith_typesubst of type_declaration| Twith_modsubst of Path.t * Longident.t Asttypes.loc| Twith_modtypesubst of module_typeand core_type = {mutable ctyp_desc : core_type_desc;mutable because of Typeclass.declare_method
mutable ctyp_type : Types.type_expr;mutable because of Typeclass.declare_method
ctyp_env : Env.t;ctyp_loc : Location.t;ctyp_attributes : attributes;}and core_type_desc = | Ttyp_any| Ttyp_var of string| Ttyp_arrow of Asttypes.arg_label * core_type * core_type| Ttyp_tuple of core_type list| Ttyp_constr of Path.t * Longident.t Asttypes.loc * core_type list| Ttyp_object of object_field list * Asttypes.closed_flag| Ttyp_class of Path.t * Longident.t Asttypes.loc * core_type list| Ttyp_alias of core_type * string| Ttyp_variant of row_field list
+ * Asttypes.closed_flag
+ * Asttypes.label list option| Ttyp_poly of string list * core_type| Ttyp_package of package_typeand package_type = {pack_path : Path.t;pack_fields : (Longident.t Asttypes.loc * core_type) list;pack_type : Types.module_type;pack_txt : Longident.t Asttypes.loc;}and value_description = {val_id : Ident.t;val_name : string Asttypes.loc;val_desc : core_type;val_val : Types.value_description;val_prim : string list;val_loc : Location.t;val_attributes : attributes;}and type_declaration = {typ_id : Ident.t;typ_name : string Asttypes.loc;typ_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;typ_type : Types.type_declaration;typ_cstrs : (core_type * core_type * Location.t) list;typ_kind : type_kind;typ_private : Asttypes.private_flag;typ_manifest : core_type option;typ_loc : Location.t;typ_attributes : attributes;}and type_kind = | Ttype_abstract| Ttype_variant of constructor_declaration list| Ttype_record of label_declaration list| Ttype_openand label_declaration = {ld_id : Ident.t;ld_name : string Asttypes.loc;ld_mutable : Asttypes.mutable_flag;ld_type : core_type;ld_loc : Location.t;ld_attributes : attributes;}and constructor_declaration = {cd_id : Ident.t;cd_name : string Asttypes.loc;cd_vars : string Asttypes.loc list;cd_args : constructor_arguments;cd_res : core_type option;cd_loc : Location.t;cd_attributes : attributes;}and type_extension = {tyext_path : Path.t;tyext_txt : Longident.t Asttypes.loc;tyext_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;tyext_constructors : extension_constructor list;tyext_private : Asttypes.private_flag;tyext_loc : Location.t;tyext_attributes : attributes;}and type_exception = {tyexn_constructor : extension_constructor;tyexn_loc : Location.t;tyexn_attributes : attribute list;}and extension_constructor = {ext_id : Ident.t;ext_name : string Asttypes.loc;ext_type : Types.extension_constructor;ext_kind : extension_constructor_kind;ext_loc : Location.t;ext_attributes : attributes;}and extension_constructor_kind = | Text_decl of string Asttypes.loc list
+ * constructor_arguments
+ * core_type option| Text_rebind of Path.t * Longident.t Asttypes.locand class_type = {cltyp_desc : class_type_desc;cltyp_type : Types.class_type;cltyp_env : Env.t;cltyp_loc : Location.t;cltyp_attributes : attributes;}and class_type_desc = | Tcty_constr of Path.t * Longident.t Asttypes.loc * core_type list| Tcty_signature of class_signature| Tcty_arrow of Asttypes.arg_label * core_type * class_type| Tcty_open of open_description * class_typeand class_signature = {csig_self : core_type;csig_fields : class_type_field list;csig_type : Types.class_signature;}and class_type_field = {ctf_desc : class_type_field_desc;ctf_loc : Location.t;ctf_attributes : attributes;}and class_type_field_desc = | Tctf_inherit of class_type| Tctf_val of string * Asttypes.mutable_flag * Asttypes.virtual_flag * core_type| Tctf_method of string
+ * Asttypes.private_flag
+ * Asttypes.virtual_flag
+ * core_type| Tctf_constraint of core_type * core_type| Tctf_attribute of attributeand class_declaration = class_expr class_infosand class_description = class_type class_infosand class_type_declaration = class_type class_infosand 'a class_infos = {ci_virt : Asttypes.virtual_flag;ci_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;ci_id_name : string Asttypes.loc;ci_id_class : Ident.t;ci_id_class_type : Ident.t;ci_id_object : Ident.t;ci_id_typehash : Ident.t;ci_expr : 'a;ci_decl : Types.class_declaration;ci_type_decl : Types.class_type_declaration;ci_loc : Location.t;ci_attributes : attributes;}type implementation = {structure : structure;coercion : module_coercion;signature : Types.signature;shape : Shape.t;}A typechecked implementation including its module structure, its exported signature, and a coercion of the module against that signature.
If an .mli file is present, the signature will come from that file and be the exported signature of the module.
If there isn't one, the signature will be inferred from the module structure.
val as_computation_pattern : pattern -> computation general_patternas_computation_pattern p is a computation pattern with description Tpat_value p, which enforces a correct placement of pat_attributes and pat_extra metadata (on the inner value pattern, rather than on the computation pattern).
val classify_pattern_desc : 'k pattern_desc -> 'k pattern_categoryval classify_pattern : 'k general_pattern -> 'k pattern_categoryval shallow_iter_pattern_desc : pattern_action -> 'k pattern_desc -> unitval shallow_map_pattern_desc :
+ pattern_transformation ->
+ 'k pattern_desc ->
+ 'k pattern_descval iter_general_pattern : pattern_action -> 'k general_pattern -> unitval exists_general_pattern : pattern_predicate -> 'k general_pattern -> boolval let_bound_idents : value_binding list -> Ident.t listval let_bound_idents_full :
+ value_binding list ->
+ (Ident.t * string Asttypes.loc * Types.type_expr) listval alpha_pat :
+ (Ident.t * Ident.t) list ->
+ 'k general_pattern ->
+ 'k general_patternAlpha conversion of patterns
val mknoloc : 'a -> 'a Asttypes.locval mkloc : 'a -> Location.t -> 'a Asttypes.locval pat_bound_idents : 'k general_pattern -> Ident.t listval pat_bound_idents_full :
+ 'k general_pattern ->
+ (Ident.t * string Asttypes.loc * Types.type_expr) listval split_pattern :
+ computation general_pattern ->
+ pattern option * pattern optionSplits an or pattern into its value (left) and exception (right) parts.
Typemod.Sig_component_kindval to_string : t -> stringTypemod.Signature_namesval simplify : Env.t -> t -> Types.signature -> Types.signatureTypemodType-checking of the module language and typed ast hooks
Warning: this module is unstable and part of compiler-libs.
module Signature_names : sig ... endval type_module :
+ Env.t ->
+ Parsetree.module_expr ->
+ Typedtree.module_expr * Shape.tval type_structure :
+ Env.t ->
+ Parsetree.structure ->
+ Typedtree.structure * Types.signature * Signature_names.t * Shape.t * Env.tval type_toplevel_phrase :
+ Env.t ->
+ Parsetree.structure ->
+ Typedtree.structure * Types.signature * Signature_names.t * Shape.t * Env.tval type_implementation :
+ string ->
+ string ->
+ string ->
+ Env.t ->
+ Parsetree.structure ->
+ Typedtree.implementationval type_interface : Env.t -> Parsetree.signature -> Typedtree.signatureval transl_signature : Env.t -> Parsetree.signature -> Typedtree.signatureval check_nongen_signature : Env.t -> Types.signature -> unitval modtype_of_package :
+ Env.t ->
+ Location.t ->
+ Path.t ->
+ (Longident.t * Types.type_expr) list ->
+ Types.module_typeval path_of_module : Typedtree.module_expr -> Path.t optionval save_signature :
+ string ->
+ Typedtree.signature ->
+ string ->
+ string ->
+ Env.t ->
+ Cmi_format.cmi_infos ->
+ unitval package_units :
+ Env.t ->
+ string list ->
+ string ->
+ string ->
+ Typedtree.module_coercionval initial_env :
+ loc:Location.t ->
+ safe_string:bool ->
+ initially_opened_module:string option ->
+ open_implicit_modules:string list ->
+ Env.tmodule Sig_component_kind : sig ... endtype hiding_error = | Illegal_shadowing of {shadowed_item_id : Ident.t;shadowed_item_kind : Sig_component_kind.t;shadowed_item_loc : Location.t;shadower_id : Ident.t;user_id : Ident.t;user_kind : Sig_component_kind.t;user_loc : Location.t;}| Appears_in_signature of {opened_item_id : Ident.t;opened_item_kind : Sig_component_kind.t;user_id : Ident.t;user_kind : Sig_component_kind.t;user_loc : Location.t;}type error = | Cannot_apply of Types.module_type| Not_included of Includemod.explanation| Cannot_eliminate_dependency of Types.module_type| Signature_expected| Structure_expected of Types.module_type| With_no_component of Longident.t| With_mismatch of Longident.t * Includemod.explanation| With_makes_applicative_functor_ill_typed of Longident.t
+ * Path.t
+ * Includemod.explanation| With_changes_module_alias of Longident.t * Ident.t * Path.t| With_cannot_remove_constrained_type| Repeated_name of Sig_component_kind.t * string| Non_generalizable of Types.type_expr| Non_generalizable_module of Types.module_type| Implementation_is_required of string| Interface_not_compiled of string| Not_allowed_in_functor_body| Not_a_packed_module of Types.type_expr| Incomplete_packed_module of Types.type_expr| Scoping_pack of Longident.t * Types.type_expr| Recursive_module_require_explicit_type| Apply_generative| Cannot_scrape_alias of Path.t| Cannot_scrape_package_type of Path.t| Badly_formed_signature of string * Typedecl.error| Cannot_hide_id of hiding_error| Invalid_type_subst_rhs| Unpackable_local_modtype_subst of Path.t| With_cannot_remove_packed_modtype of Path.t * Types.module_typeexception Error of Location.t * Env.t * errorexception Error_forward of Location.errorval report_error : Env.t -> loc:Location.t -> error -> Location.errorTypeoptval is_function_type :
+ Env.t ->
+ Types.type_expr ->
+ (Types.type_expr * Types.type_expr) optionval is_base_type : Env.t -> Types.type_expr -> Path.t -> boolval maybe_pointer_type :
+ Env.t ->
+ Types.type_expr ->
+ Lambda.immediate_or_pointerval maybe_pointer : Typedtree.expression -> Lambda.immediate_or_pointerval array_type_kind : Env.t -> Types.type_expr -> Lambda.array_kindval array_kind : Typedtree.expression -> Lambda.array_kindval array_pattern_kind : Typedtree.pattern -> Lambda.array_kindval bigarray_type_kind_and_layout :
+ Env.t ->
+ Types.type_expr ->
+ Lambda.bigarray_kind * Lambda.bigarray_layoutval value_kind : Env.t -> Types.type_expr -> Lambda.value_kindval function_return_value_kind : Env.t -> Types.type_expr -> Lambda.value_kindval classify_lazy_argument :
+ Typedtree.expression ->
+ [ `Constant_or_function
+ | `Float_that_cannot_be_shortcut
+ | `Identifier of [ `Forward_value | `Other ]
+ | `Other ]val value_kind_union :
+ Lambda.value_kind ->
+ Lambda.value_kind ->
+ Lambda.value_kindvalue_kind_union k1 k2 is a value_kind at least as general as k1 and k2
Types.MethSetval empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Types.Methsval empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Types.Separabilitysee Typedecl_separability for an explanation of separability and separability modes.
val print : Stdlib.Format.formatter -> t -> unitval rank : t -> intModes are ordered from the least to the most demanding: Ind < Sep < Deepsep. 'rank' maps them to integers in an order-respecting way: m1 < m2 <=> rank m1 < rank m2
max_mode m1 m2 returns the most demanding mode. It is used to express the conjunction of two parameter mode constraints.
type signature = t listThe 'separability signature' of a type assigns a mode for each of its parameters. ('a, 'b) t has mode (m1, m2) if (t1, t2) t is separable whenever t1, t2 have mode m1, m2.
val print_signature : Stdlib.Format.formatter -> signature -> unitval default_signature : arity:int -> signatureThe most pessimistic separability for a completely unknown type.
Types.TransientTypeOpsComparisons for functors
Types.Transient_exprOperations on transient_expr
val create : type_desc -> level:int -> scope:int -> id:int -> transient_exprval set_desc : transient_expr -> type_desc -> unitval set_level : transient_expr -> int -> unitval set_scope : transient_expr -> int -> unitval repr : type_expr -> transient_exprval type_expr : transient_expr -> type_exprval coerce : type_expr -> transient_exprCoerce without normalizing with repr
Types.VarSetval empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
map f s is the set whose elements are f a0,f a1... f
+ aN, where a0,a1...aN are the elements of s.
The elements are passed to f in increasing order with respect to the ordering over the type of the elements.
If no element of s is changed by f, s is returned unchanged. (If each output of f is physically equal to its input, the returned set is physically equal to s.)
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
of_list l creates a set from a list of elements. This is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements.
to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Types.Varianceval null : tval full : tval covariant : tval unknown : tval get_upper : t -> bool * boolval get_lower : t -> bool * bool * bool * boolval unknown_signature : injective:bool -> arity:int -> t listThe most pessimistic variance for a completely unknown type.
Types.Varsval empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
TypesTypes defines the representation of types and declarations (that is, the content of module signatures).
CMI files are made of marshalled types.
Asttypes exposes basic definitions shared both by Parsetree and Types.
Type expressions for the core language.
The type_desc variant defines all the possible type expressions one can find in OCaml. type_expr wraps this with some annotations.
The level field tracks the level of polymorphism associated to a type, guiding the generalization algorithm. Put shortly, when referring to a type in a given environment, both the type and the environment have a level. If the type has an higher level, then it can be considered fully polymorphic (type variables will be printed as 'a), otherwise it'll be weakly polymorphic, or non generalized (type variables printed as '_a). See http://okmij.org/ftp/ML/generalization.html for more information.
Note about type_declaration: one should not make the confusion between type_expr and type_declaration.
type_declaration refers specifically to the type construct in OCaml language, where you create and name a new type or type alias.
type_expr is used when you refer to existing types, e.g. when annotating the expected type of a value.
Also, as the type system of OCaml is generative, a type_declaration can have the side-effect of introducing a new type constructor, different from all other known types. Whereas type_expr is a pure construct which allows referring to existing types.
Note on mutability: TBD.
type type_desc = | Tvar of string optionTvar (Some "a") ==> 'a or '_a Tvar None ==> _
| Tarrow of Asttypes.arg_label * type_expr * type_expr * commutableTarrow (Nolabel, e1, e2, c) ==> e1 -> e2 Tarrow (Labelled "l", e1, e2, c) ==> l:e1 -> e2 Tarrow (Optional "l", e1, e2, c) ==> ?l:e1 -> e2
See commutable for the last argument.
| Ttuple of type_expr listTtuple [t1;...;tn] ==> (t1 * ... * tn)
| Tconstr of Path.t * type_expr list * abbrev_memo refTconstr (`A.B.t', [t1;...;tn], _) ==> (t1,...,tn) A.B.t The last parameter keep tracks of known expansions, see abbrev_memo.
| Tobject of type_expr * (Path.t * type_expr list) option refTobject (`f1:t1;...;fn: tn', `None') ==> < f1: t1; ...; fn: tn > f1, fn are represented as a linked list of types using Tfield and Tnil constructors.
Tobject (_, `Some (`A.ct', [t1;...;tn]') ==> (t1, ..., tn) A.ct. where A.ct is the type of some class.
There are also special cases for so-called "class-types", cf. Typeclass and Ctype.set_object_name:
Tobject (Tfield(_,_,...(Tfield(_,_,rv)...),
+ Some(`A.#ct`, [rv;t1;...;tn]) ==> (t1, ..., tn) #A.ct Tobject (_, Some(`A.#ct`, [Tnil;t1;...;tn]) ==> (t1, ..., tn) A.ct
where rv is the hidden row variable.
| Tfield of string * field_kind * type_expr * type_exprTfield ("foo", field_public, t, ts) ==> <...; foo : t; ts>
| TnilTnil ==> <...; >
| Tlink of type_exprIndirection used by unification engine.
*)| Tsubst of type_expr * type_expr optionTsubst is used temporarily to store information in low-level functions manipulating representation of types, such as instantiation or copy. The first argument contains a copy of the original node. The second is available only when the first is the row variable of a polymorphic variant. It then contains a copy of the whole variant. This constructor should not appear outside of these cases.
| Tvariant of row_descRepresentation of polymorphic variants, see row_desc.
| Tunivar of string optionOccurrence of a type variable introduced by a forall quantifier / Tpoly.
| Tpoly of type_expr * type_expr listTpoly (ty,tyl) ==> 'a1... 'an. ty, where 'a1 ... 'an are names given to types in tyl and occurrences of those types in ty.
| Tpackage of Path.t * (Longident.t * type_expr) listType of a first-class module (a.k.a package).
*)and abbrev_memo = | MnilNo known abbreviation
*)| Mcons of Asttypes.private_flag * Path.t * type_expr * type_expr * abbrev_memoFound one abbreviation. A valid abbreviation should be at least as visible and reachable by the same path. The first expression is the abbreviation and the second the expansion.
*)| Mlink of abbrev_memo refAbbreviations can be found after this indirection
*)abbrev_memo allows one to keep track of different expansions of a type alias. This is done for performance purposes.
For instance, when defining type 'a pair = 'a * 'a, when one refers to an 'a pair, it is just a shortcut for the 'a * 'a type. This expansion will be stored in the abbrev_memo of the corresponding Tconstr node.
In practice, abbrev_memo behaves like list of expansions with a mutable tail.
Note on marshalling: abbrev_memo must not appear in saved types. Btype, with cleanup_abbrev and memo, takes care of tracking and removing abbreviations.
commutable is a flag appended to every arrow type.
When typing an application, if the type of the functional is known, its type is instantiated with commu_ok arrows, otherwise as commu_var ().
When the type is not known, the application will be used to infer the actual type. This is fragile in presence of labels where there is no principal type.
Two incompatible applications must rely on is_commu_ok arrows, otherwise they will trigger an error.
let f g = g ~a:() ~b:(); g ~b:() ~a:();
Error: This function is applied to arguments in an order different from other calls. This is only allowed when the real type is known.
val is_commu_ok : commutable -> boolval commu_ok : commutableval commu_var : unit -> commutablefield_kind indicates the accessibility of a method.
An Fprivate field may become Fpublic or Fabsent during unification, but not the other way round.
The same field_kind is kept shared when copying Tfield nodes so that the copies of the self-type of a class share the same accessibility (see also PR#10539).
val field_kind_repr : field_kind -> field_kind_viewval field_public : field_kindval field_absent : field_kindval field_private : unit -> field_kindval field_kind_internal_repr : field_kind -> field_kindGetters for type_expr; calls repr before answering a value
val get_level : type_expr -> intval get_scope : type_expr -> intval get_id : type_expr -> inttype transient_expr = private {mutable desc : type_desc;mutable level : int;mutable scope : int;id : int;}Transient type_expr. Should only be used immediately after Transient_expr.repr
module Transient_expr : sig ... endOperations on transient_expr
Functions and definitions moved from Btype
module TransientTypeOps : sig ... endComparisons for functors
Comparisons for type_expr; cannot be used for functors
Constructor and accessors for row_desc
`X | `Y (row_closed = true) < `X | `Y (row_closed = true) > `X | `Y (row_closed = false) < `X | `Y > `X (row_closed = true)
type t = > `X as 'a (row_more = Tvar a) type t = private > `X (row_more = Tconstr ("t#row", , ref Mnil))
And for:
let f = function `X -> `X -> | `Y -> `X
the type of "f" will be a Tarrow whose lhs will (basically) be:
Tvariant row_fields = [("X", _)];
+ row_more =
+ Tvariant { row_fields = [("Y", _)];
+ row_more =
+ Tvariant { row_fields = [];
+ row_more = _;
+ _ ; _
}
; _
}
val create_row :
+ fields:(Asttypes.label * row_field) list ->
+ more:type_expr ->
+ closed:bool ->
+ fixed:fixed_explanation option ->
+ name:(Path.t * type_expr list) option ->
+ row_descval row_fields : row_desc -> (Asttypes.label * row_field) listval row_closed : row_desc -> boolval row_fixed : row_desc -> fixed_explanation optionval get_row_field : Asttypes.label -> row_desc -> row_fieldtype row_desc_repr = | Row of {fields : (Asttypes.label * row_field) list;more : type_expr;closed : bool;fixed : fixed_explanation option;name : (Path.t * type_expr list) option;}get all fields at once; different from the old row_repr
val row_repr : row_desc -> row_desc_reprval row_field_repr : row_field -> row_field_viewval rf_absent : row_fieldval changed_row_field_exts : row_field list -> (unit -> unit) -> boolmodule Uid = Shape.Uidtype value_description = {val_type : type_expr;val_kind : value_kind;val_loc : Location.t;val_attributes : Parsetree.attributes;val_uid : Uid.t;}and value_kind = | Val_reg| Val_prim of Primitive.description| Val_ivar of Asttypes.mutable_flag * string| Val_self of class_signature * self_meths * Ident.t Vars.t * string| Val_anc of class_signature * Ident.t Meths.t * stringand class_signature = {csig_self : type_expr;mutable csig_self_row : type_expr;mutable csig_vars : (Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr)
+ Vars.t;mutable csig_meths : (method_privacy * Asttypes.virtual_flag * type_expr)
+ Meths.t;}module Variance : sig ... endmodule Separability : sig ... endsee Typedecl_separability for an explanation of separability and separability modes.
type type_declaration = {type_params : type_expr list;type_arity : int;type_kind : type_decl_kind;type_private : Asttypes.private_flag;type_manifest : type_expr option;type_variance : Variance.t list;type_separability : Separability.t list;type_is_newtype : bool;type_expansion_scope : int;type_loc : Location.t;type_attributes : Parsetree.attributes;type_immediate : Type_immediacy.t;type_unboxed_default : bool;type_uid : Uid.t;}and type_decl_kind = (label_declaration, constructor_declaration) type_kindand ('lbl, 'cstr) type_kind = | Type_abstract| Type_record of 'lbl list * record_representation| Type_variant of 'cstr list * variant_representation| Type_openand record_representation = | Record_regular| Record_float| Record_unboxed of bool| Record_inlined of int| Record_extension of Path.tand label_declaration = {ld_id : Ident.t;ld_mutable : Asttypes.mutable_flag;ld_type : type_expr;ld_loc : Location.t;ld_attributes : Parsetree.attributes;ld_uid : Uid.t;}and constructor_declaration = {cd_id : Ident.t;cd_args : constructor_arguments;cd_res : type_expr option;cd_loc : Location.t;cd_attributes : Parsetree.attributes;cd_uid : Uid.t;}type extension_constructor = {ext_type_path : Path.t;ext_type_params : type_expr list;ext_args : constructor_arguments;ext_ret_type : type_expr option;ext_private : Asttypes.private_flag;ext_loc : Location.t;ext_attributes : Parsetree.attributes;ext_uid : Uid.t;}type class_type = | Cty_constr of Path.t * type_expr list * class_type| Cty_signature of class_signature| Cty_arrow of Asttypes.arg_label * type_expr * class_typetype class_declaration = {cty_params : type_expr list;mutable cty_type : class_type;cty_path : Path.t;cty_new : type_expr option;cty_variance : Variance.t list;cty_loc : Location.t;cty_attributes : Parsetree.attributes;cty_uid : Uid.t;}type class_type_declaration = {clty_params : type_expr list;clty_type : class_type;clty_path : Path.t;clty_variance : Variance.t list;clty_loc : Location.t;clty_attributes : Parsetree.attributes;clty_uid : Uid.t;}type module_type = | Mty_ident of Path.t| Mty_signature of signature| Mty_functor of functor_parameter * module_type| Mty_alias of Path.tand signature = signature_item listand signature_item = | Sig_value of Ident.t * value_description * visibility| Sig_type of Ident.t * type_declaration * rec_status * visibility| Sig_typext of Ident.t * extension_constructor * ext_status * visibility| Sig_module of Ident.t
+ * module_presence
+ * module_declaration
+ * rec_status
+ * visibility| Sig_modtype of Ident.t * modtype_declaration * visibility| Sig_class of Ident.t * class_declaration * rec_status * visibility| Sig_class_type of Ident.t * class_type_declaration * rec_status * visibilityand module_declaration = {md_type : module_type;md_attributes : Parsetree.attributes;md_loc : Location.t;md_uid : Uid.t;}and modtype_declaration = {mtd_type : module_type option;mtd_attributes : Parsetree.attributes;mtd_loc : Location.t;mtd_uid : Uid.t;}val item_visibility : signature_item -> visibilitytype constructor_description = {cstr_name : string;cstr_res : type_expr;cstr_existentials : type_expr list;cstr_args : type_expr list;cstr_arity : int;cstr_tag : constructor_tag;cstr_consts : int;cstr_nonconsts : int;cstr_generalized : bool;cstr_private : Asttypes.private_flag;cstr_loc : Location.t;cstr_attributes : Parsetree.attributes;cstr_inlined : type_declaration option;cstr_uid : Uid.t;}and constructor_tag = | Cstr_constant of int| Cstr_block of int| Cstr_unboxed| Cstr_extension of Path.t * boolval equal_tag : constructor_tag -> constructor_tag -> boolval may_equal_constr :
+ constructor_description ->
+ constructor_description ->
+ booltype label_description = {lbl_name : string;lbl_res : type_expr;lbl_arg : type_expr;lbl_mut : Asttypes.mutable_flag;lbl_pos : int;lbl_all : label_description array;lbl_repres : record_representation;lbl_private : Asttypes.private_flag;lbl_loc : Location.t;lbl_attributes : Parsetree.attributes;lbl_uid : Uid.t;}Extracts the list of "value" identifiers bound by a signature. "Value" identifiers are identifiers for signature components that correspond to a run-time value: values, extensions, modules, classes. Note: manifest primitives do not correspond to a run-time value!
val signature_item_id : signature_item -> Ident.tval snapshot : unit -> snapshotval backtrack : cleanup_abbrev:(unit -> unit) -> snapshot -> unitval undo_first_change_after : snapshot -> unitval undo_compress : snapshot -> unitFunctions to use when modifying a type (only Ctype?). The old values are logged and reverted on backtracking.
val set_level : type_expr -> int -> unitval set_scope : type_expr -> int -> unitval link_kind : inside:field_kind -> field_kind -> unitval link_commu : inside:commutable -> commutable -> unitval set_commu_ok : commutable -> unitTypetexpval make_poly_univars : string list -> poly_univarsval check_poly_univars :
+ Env.t ->
+ Location.t ->
+ poly_univars ->
+ Types.type_expr listval instance_poly_univars :
+ Env.t ->
+ Location.t ->
+ poly_univars ->
+ Types.type_expr listval transl_simple_type :
+ Env.t ->
+ ?univars:poly_univars ->
+ bool ->
+ Parsetree.core_type ->
+ Typedtree.core_typeval transl_simple_type_univars :
+ Env.t ->
+ Parsetree.core_type ->
+ Typedtree.core_typeval transl_simple_type_delayed :
+ Env.t ->
+ Parsetree.core_type ->
+ Typedtree.core_type * Types.type_expr * (unit -> unit)val transl_type_scheme : Env.t -> Parsetree.core_type -> Typedtree.core_typeval type_variable : Location.t -> string -> Types.type_exprval transl_type_param : Env.t -> Parsetree.core_type -> Typedtree.core_typeval narrow : unit -> variable_contextval widen : variable_context -> unittype error = | Unbound_type_variable of string| Undefined_type_constructor of Path.t| Type_arity_mismatch of Longident.t * int * int| Bound_type_variable of string| Recursive_type| Unbound_row_variable of Longident.t| Type_mismatch of Errortrace.unification_error| Alias_type_mismatch of Errortrace.unification_error| Present_has_conjunction of string| Present_has_no_type of string| Constructor_mismatch of Types.type_expr * Types.type_expr| Not_a_variant of Types.type_expr| Invalid_variable_name of string| Cannot_quantify of string * Types.type_expr| Multiple_constraints_on_type of Longident.t| Method_mismatch of string * Types.type_expr * Types.type_expr| Opened_object of Path.t option| Not_an_object of Types.type_exprexception Error of Location.t * Env.t * errorval report_error : Env.t -> Stdlib.Format.formatter -> error -> unitval transl_modtype_longident :
+ (Location.t -> Env.t -> Longident.t -> Path.t) refval transl_modtype :
+ (Env.t -> Parsetree.module_type -> Typedtree.module_type) refval create_package_mty :
+ Location.t ->
+ Env.t ->
+ Parsetree.package_type ->
+ (Longident.t Asttypes.loc * Parsetree.core_type) list * Parsetree.module_typeUn_anfval apply :
+ what:Symbol.t ->
+ ppf_dump:Stdlib.Format.formatter ->
+ Clambda.ulambda ->
+ Clambda.ulambdaExpand ANF-like constructs so that pattern matches in Cmmgen will work correctly.
Unbox_closuresTurn free variables of closures into specialised arguments. The aim is to cause the closure to become closed.
val rewrite_set_of_closures :
+ env:Inline_and_simplify_aux.Env.t ->
+ duplicate_function:
+ (env:Inline_and_simplify_aux.Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ fun_var:Variable.t ->
+ new_fun_var:Variable.t ->
+ Flambda.function_declaration * Flambda.specialised_to Variable.Map.t) ->
+ set_of_closures:Flambda.set_of_closures ->
+ (Flambda.expr * Inlining_cost.Benefit.t) optionUnbox_free_vars_of_closuresWhen approximations of free variables of closures indicate that they are closures or blocks, rewrite projections from such blocks to new variables (which become free in the closures), with the defining expressions of the projections lifted out of the corresponding sets of closures.
val run :
+ env:Inline_and_simplify_aux.Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ (Flambda.expr * Inlining_cost.Benefit.t) optionUnbox_specialised_argsWhen approximations of specialised arguments indicate that they are closures or blocks, add more specialised arguments corresponding to the projections from such blocks (with definitions of such projections lifted out), such that the original specialised arguments may later be eliminated.
This in particular enables elimination of closure allocations in examples such as:
let rec map f = function | -> | a::l -> let r = f a in r :: map f l
let g x = map (fun y -> x + y) 1; 2; 3; 4
Here, the specialised version of map initially has a specialised argument f; and upon inlining there will be a projection of x from the closure of f. This pass adds a new specialised argument to carry that projection, at which point the closure of f is redundant.
val rewrite_set_of_closures :
+ env:Inline_and_simplify_aux.Env.t ->
+ duplicate_function:
+ (env:Inline_and_simplify_aux.Env.t ->
+ set_of_closures:Flambda.set_of_closures ->
+ fun_var:Variable.t ->
+ new_fun_var:Variable.t ->
+ Flambda.function_declaration * Flambda.specialised_to Variable.Map.t) ->
+ set_of_closures:Flambda.set_of_closures ->
+ (Flambda.expr * Inlining_cost.Benefit.t) optionUnix.LargeFileFile operations on large files. This sub-module provides 64-bit variants of the functions lseek (for positioning a file descriptor), truncate and ftruncate (for changing the size of a file), and stat, lstat and fstat (for obtaining information on files). These alternate functions represent positions and sizes by 64-bit integers (type int64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
val lseek : file_descr -> int64 -> seek_command -> int64See lseek.
val ftruncate : file_descr -> int64 -> unitSee ftruncate.
type stats = {st_dev : int;Device number
*)st_ino : int;Inode number
*)st_kind : file_kind;Kind of the file
*)st_perm : file_perm;Access rights
*)st_nlink : int;Number of links
*)st_uid : int;User id of the owner
*)st_gid : int;Group ID of the file's group
*)st_rdev : int;Device ID (if special file)
*)st_size : int64;Size in bytes
*)st_atime : float;Last access time
*)st_mtime : float;Last modification time
*)st_ctime : float;Last status change time
*)}val stat : string -> statsval lstat : string -> statsval fstat : file_descr -> statsUnixInterface to the Unix system.
To use the labeled version of this module, add module Unix = UnixLabels in your implementation.
Note: all the functions of this module (except error_message and handle_unix_error) are liable to raise the Unix_error exception whenever the underlying system call signals an error.
type error = | E2BIGArgument list too long
*)| EACCESPermission denied
*)| EAGAINResource temporarily unavailable; try again
*)| EBADFBad file descriptor
*)| EBUSYResource unavailable
*)| ECHILDNo child process
*)| EDEADLKResource deadlock would occur
*)| EDOMDomain error for math functions, etc.
*)| EEXISTFile exists
*)| EFAULTBad address
*)| EFBIGFile too large
*)| EINTRFunction interrupted by signal
*)| EINVALInvalid argument
*)| EIOHardware I/O error
*)| EISDIRIs a directory
*)| EMFILEToo many open files by the process
*)| EMLINKToo many links
*)| ENAMETOOLONGFilename too long
*)| ENFILEToo many open files in the system
*)| ENODEVNo such device
*)| ENOENTNo such file or directory
*)| ENOEXECNot an executable file
*)| ENOLCKNo locks available
*)| ENOMEMNot enough memory
*)| ENOSPCNo space left on device
*)| ENOSYSFunction not supported
*)| ENOTDIRNot a directory
*)| ENOTEMPTYDirectory not empty
*)| ENOTTYInappropriate I/O control operation
*)| ENXIONo such device or address
*)| EPERMOperation not permitted
*)| EPIPEBroken pipe
*)| ERANGEResult too large
*)| EROFSRead-only file system
*)| ESPIPEInvalid seek e.g. on a pipe
*)| ESRCHNo such process
*)| EXDEVInvalid link
*)| EWOULDBLOCKOperation would block
*)| EINPROGRESSOperation now in progress
*)| EALREADYOperation already in progress
*)| ENOTSOCKSocket operation on non-socket
*)| EDESTADDRREQDestination address required
*)| EMSGSIZEMessage too long
*)| EPROTOTYPEProtocol wrong type for socket
*)| ENOPROTOOPTProtocol not available
*)| EPROTONOSUPPORTProtocol not supported
*)| ESOCKTNOSUPPORTSocket type not supported
*)| EOPNOTSUPPOperation not supported on socket
*)| EPFNOSUPPORTProtocol family not supported
*)| EAFNOSUPPORTAddress family not supported by protocol family
*)| EADDRINUSEAddress already in use
*)| EADDRNOTAVAILCan't assign requested address
*)| ENETDOWNNetwork is down
*)| ENETUNREACHNetwork is unreachable
*)| ENETRESETNetwork dropped connection on reset
*)| ECONNABORTEDSoftware caused connection abort
*)| ECONNRESETConnection reset by peer
*)| ENOBUFSNo buffer space available
*)| EISCONNSocket is already connected
*)| ENOTCONNSocket is not connected
*)| ESHUTDOWNCan't send after socket shutdown
*)| ETOOMANYREFSToo many references: can't splice
*)| ETIMEDOUTConnection timed out
*)| ECONNREFUSEDConnection refused
*)| EHOSTDOWNHost is down
*)| EHOSTUNREACHNo route to host
*)| ELOOPToo many levels of symbolic links
*)| EOVERFLOWFile size or position not representable
*)| EUNKNOWNERR of intUnknown error
*)The type of error codes. Errors defined in the POSIX standard and additional errors from UNIX98 and BSD. All other errors are mapped to EUNKNOWNERR.
exception Unix_error of error * string * stringRaised by the system calls below when an error is encountered. The first component is the error code; the second component is the function name; the third component is the string parameter to the function, if it has one, or the empty string otherwise.
UnixLabels.Unix_error and Unix.Unix_error are the same, and catching one will catch the other.
val error_message : error -> stringReturn a string describing the given error code.
handle_unix_error f x applies f to x and returns the result. If the exception Unix_error is raised, it prints a message describing the error and exits with code 2.
Return the process environment, as an array of strings with the format ``variable=value''. The returned array is empty if the process has special privileges.
Return the process environment, as an array of strings with the format ``variable=value''. Unlike environment, this function returns a populated array even if the process has special privileges. See the documentation for unsafe_getenv for more details.
Return the value associated to a variable in the process environment, unless the process has special privileges.
Return the value associated to a variable in the process environment.
Unlike getenv, this function returns the value even if the process has special privileges. It is considered unsafe because the programmer of a setuid or setgid program must be careful to avoid using maliciously crafted environment variables in the search path for executables, the locations for temporary files or logs, and the like.
putenv name value sets the value associated to a variable in the process environment. name is the name of the environment variable, and value its new associated value.
The termination status of a process. See module Sys for the definitions of the standard signal numbers. Note that they are not the numbers used by the OS.
Flags for waitpid.
execv prog args execute the program in file prog, with the arguments args, and the current process environment. These execv* functions never return: on success, the current program is replaced by the new one.
Same as execv, except that the third argument provides the environment to the program executed.
Same as execv, except that the program is searched in the path.
Same as execve, except that the program is searched in the path.
Fork a new process. The returned integer is 0 for the child process, the pid of the child process for the parent process.
val wait : unit -> int * process_statusWait until one of the children processes die, and return its pid and termination status.
val waitpid : wait_flag list -> int -> int * process_statusSame as wait, but waits for the child process whose pid is given. A pid of -1 means wait for any child. A pid of 0 means wait for any child in the same process group as the current process. Negative pid arguments represent process groups. The list of options indicates whether waitpid should return immediately without waiting, and whether it should report stopped children.
On Windows: can only wait for a given PID, not any child process.
val system : string -> process_statusExecute the given command, wait until it terminates, and return its termination status. The string is interpreted by the shell /bin/sh (or the command interpreter cmd.exe on Windows) and therefore can contain redirections, quotes, variables, etc. To properly quote whitespace and shell special characters occurring in file names or command arguments, the use of Filename.quote_command is recommended. The result WEXITED 127 indicates that the shell couldn't be executed.
Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. Unlike Stdlib.exit, Unix._exit performs no finalization whatsoever: functions registered with Stdlib.at_exit are not called, input/output channels are not flushed, and the C run-time system is not finalized either.
The typical use of Unix._exit is after a Unix.fork operation, when the child process runs into a fatal error and must exit. In this case, it is preferable to not perform any finalization action in the child process, as these actions could interfere with similar actions performed by the parent process. For example, output channels should not be flushed by the child process, as the parent process may flush them again later, resulting in duplicate output.
Change the process priority. The integer argument is added to the ``nice'' value. (Higher values of the ``nice'' value mean lower priorities.) Return the new nice value.
val stdin : file_descrFile descriptor for standard input.
val stdout : file_descrFile descriptor for standard output.
val stderr : file_descrFile descriptor for standard error.
type open_flag = | O_RDONLYOpen for reading
*)| O_WRONLYOpen for writing
*)| O_RDWROpen for reading and writing
*)| O_NONBLOCKOpen in non-blocking mode
*)| O_APPENDOpen for append
*)| O_CREATCreate if nonexistent
*)| O_TRUNCTruncate to 0 length if existing
*)| O_EXCLFail if existing
*)| O_NOCTTYDon't make this dev a controlling tty
*)| O_DSYNCWrites complete as `Synchronised I/O data integrity completion'
*)| O_SYNCWrites complete as `Synchronised I/O file integrity completion'
*)| O_RSYNCReads complete as writes (depending on O_SYNC/O_DSYNC)
*)| O_SHARE_DELETEWindows only: allow the file to be deleted while still open
*)| O_CLOEXECSet the close-on-exec flag on the descriptor returned by openfile. See set_close_on_exec for more information.
| O_KEEPEXECClear the close-on-exec flag. This is currently the default.
*)The flags to openfile.
The type of file access rights, e.g. 0o640 is read and write for user, read for group, none for others
val openfile : string -> open_flag list -> file_perm -> file_descrOpen the named file with the given flags. Third argument is the permissions to give to the file if it is created (see umask). Return a file descriptor on the named file.
val close : file_descr -> unitClose a file descriptor.
val fsync : file_descr -> unitFlush file buffers to disk.
val read : file_descr -> bytes -> int -> int -> intread fd buf pos len reads len bytes from descriptor fd, storing them in byte sequence buf, starting at position pos in buf. Return the number of bytes actually read.
val write : file_descr -> bytes -> int -> int -> intwrite fd buf pos len writes len bytes to descriptor fd, taking them from byte sequence buf, starting at position pos in buff. Return the number of bytes actually written. write repeats the writing operation until all bytes have been written or an error occurs.
val single_write : file_descr -> bytes -> int -> int -> intSame as write, but attempts to write only once. Thus, if an error occurs, single_write guarantees that no data has been written.
val write_substring : file_descr -> string -> int -> int -> intSame as write, but take the data from a string instead of a byte sequence.
val single_write_substring : file_descr -> string -> int -> int -> intSame as single_write, but take the data from a string instead of a byte sequence.
val in_channel_of_descr : file_descr -> in_channelCreate an input channel reading from the given descriptor. The channel is initially in binary mode; use set_binary_mode_in ic false if text mode is desired. Text mode is supported only if the descriptor refers to a file or pipe, but is not supported if it refers to a socket.
On Windows: Stdlib.set_binary_mode_in always fails on channels created with this function.
Beware that input channels are buffered, so more characters may have been read from the descriptor than those accessed using channel functions. Channels also keep a copy of the current position in the file.
Closing the channel ic returned by in_channel_of_descr fd using close_in ic also closes the underlying descriptor fd. It is incorrect to close both the channel ic and the descriptor fd.
If several channels are created on the same descriptor, one of the channels must be closed, but not the others. Consider for example a descriptor s connected to a socket and two channels ic = in_channel_of_descr s and oc = out_channel_of_descr s. The recommended closing protocol is to perform close_out oc, which flushes buffered output to the socket then closes the socket. The ic channel must not be closed and will be collected by the GC eventually.
val out_channel_of_descr : file_descr -> out_channelCreate an output channel writing on the given descriptor. The channel is initially in binary mode; use set_binary_mode_out oc false if text mode is desired. Text mode is supported only if the descriptor refers to a file or pipe, but is not supported if it refers to a socket.
On Windows: Stdlib.set_binary_mode_out always fails on channels created with this function.
Beware that output channels are buffered, so you may have to call Stdlib.flush to ensure that all data has been sent to the descriptor. Channels also keep a copy of the current position in the file.
Closing the channel oc returned by out_channel_of_descr fd using close_out oc also closes the underlying descriptor fd. It is incorrect to close both the channel ic and the descriptor fd.
See Unix.in_channel_of_descr for a discussion of the closing protocol when several channels are created on the same descriptor.
val descr_of_in_channel : in_channel -> file_descrReturn the descriptor corresponding to an input channel.
val descr_of_out_channel : out_channel -> file_descrReturn the descriptor corresponding to an output channel.
Positioning modes for lseek.
val lseek : file_descr -> int -> seek_command -> intSet the current position for a file descriptor, and return the resulting offset (from the beginning of the file).
val ftruncate : file_descr -> int -> unitTruncates the file corresponding to the given descriptor to the given size.
type stats = {st_dev : int;Device number
*)st_ino : int;Inode number
*)st_kind : file_kind;Kind of the file
*)st_perm : file_perm;Access rights
*)st_nlink : int;Number of links
*)st_uid : int;User id of the owner
*)st_gid : int;Group ID of the file's group
*)st_rdev : int;Device ID (if special file)
*)st_size : int;Size in bytes
*)st_atime : float;Last access time
*)st_mtime : float;Last modification time
*)st_ctime : float;Last status change time
*)}The information returned by the stat calls.
val stat : string -> statsReturn the information for the named file.
val lstat : string -> statsSame as stat, but in case the file is a symbolic link, return the information for the link itself.
val fstat : file_descr -> statsReturn the information for the file associated with the given descriptor.
val isatty : file_descr -> boolReturn true if the given file descriptor refers to a terminal or console window, false otherwise.
module LargeFile : sig ... endFile operations on large files. This sub-module provides 64-bit variants of the functions lseek (for positioning a file descriptor), truncate and ftruncate (for changing the size of a file), and stat, lstat and fstat (for obtaining information on files). These alternate functions represent positions and sizes by 64-bit integers (type int64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
val map_file :
+ file_descr ->
+ ?pos:int64 ->
+ ('a, 'b) Stdlib.Bigarray.kind ->
+ 'c Stdlib.Bigarray.layout ->
+ bool ->
+ int array ->
+ ('a, 'b, 'c) Stdlib.Bigarray.Genarray.tMemory mapping of a file as a Bigarray. map_file fd kind layout shared dims returns a Bigarray of kind kind, layout layout, and dimensions as specified in dims. The data contained in this Bigarray are the contents of the file referred to by the file descriptor fd (as opened previously with openfile, for example). The optional pos parameter is the byte offset in the file of the data being mapped; it defaults to 0 (map from the beginning of the file).
If shared is true, all modifications performed on the array are reflected in the file. This requires that fd be opened with write permissions. If shared is false, modifications performed on the array are done in memory only, using copy-on-write of the modified pages; the underlying file is not affected.
Genarray.map_file is much more efficient than reading the whole file in a Bigarray, modifying that Bigarray, and writing it afterwards.
To adjust automatically the dimensions of the Bigarray to the actual size of the file, the major dimension (that is, the first dimension for an array with C layout, and the last dimension for an array with Fortran layout) can be given as -1. Genarray.map_file then determines the major dimension from the size of the file. The file must contain an integral number of sub-arrays as determined by the non-major dimensions, otherwise Failure is raised.
If all dimensions of the Bigarray are given, the file size is matched against the size of the Bigarray. If the file is larger than the Bigarray, only the initial portion of the file is mapped to the Bigarray. If the file is smaller than the big array, the file is automatically grown to the size of the Bigarray. This requires write permissions on fd.
Array accesses are bounds-checked, but the bounds are determined by the initial call to map_file. Therefore, you should make sure no other process modifies the mapped file while you're accessing it, or a SIGBUS signal may be raised. This happens, for instance, if the file is shrunk.
Invalid_argument or Failure may be raised in cases where argument validation fails.
Removes the named file.
If the named file is a directory, raises:
EPERM on POSIX compliant systemEISDIR on Linux >= 2.1.132EACCESS on Windowsrename src dst changes the name of a file from src to dst, moving it between directories if needed. If dst already exists, its contents will be replaced with those of src. Depending on the operating system, the metadata (permissions, owner, etc) of dst can either be preserved or be replaced by those of src.
link ?follow src dst creates a hard link named dst to the file named src.
realpath p is an absolute pathname for p obtained by resolving all extra / characters, relative path segments and symbolic links.
Flags for the access call.
val chmod : string -> file_perm -> unitChange the permissions of the named file.
val fchmod : file_descr -> file_perm -> unitChange the permissions of an opened file.
val fchown : file_descr -> int -> int -> unitChange the owner uid and owner gid of an opened file.
val access : string -> access_permission list -> unitCheck that the process has the given permissions over the named file.
On Windows: execute permission X_OK cannot be tested, just tests for read permission instead.
val dup : ?cloexec:bool -> file_descr -> file_descrReturn a new file descriptor referencing the same file as the given descriptor. See set_close_on_exec for documentation on the cloexec optional argument.
val dup2 : ?cloexec:bool -> file_descr -> file_descr -> unitdup2 src dst duplicates src to dst, closing dst if already opened. See set_close_on_exec for documentation on the cloexec optional argument.
val set_nonblock : file_descr -> unitSet the ``non-blocking'' flag on the given descriptor. When the non-blocking flag is set, reading on a descriptor on which there is temporarily no data available raises the EAGAIN or EWOULDBLOCK error instead of blocking; writing on a descriptor on which there is temporarily no room for writing also raises EAGAIN or EWOULDBLOCK.
val clear_nonblock : file_descr -> unitClear the ``non-blocking'' flag on the given descriptor. See set_nonblock.
val set_close_on_exec : file_descr -> unitSet the ``close-on-exec'' flag on the given descriptor. A descriptor with the close-on-exec flag is automatically closed when the current process starts another program with one of the exec, create_process and open_process functions.
It is often a security hole to leak file descriptors opened on, say, a private file to an external program: the program, then, gets access to the private file and can do bad things with it. Hence, it is highly recommended to set all file descriptors ``close-on-exec'', except in the very few cases where a file descriptor actually needs to be transmitted to another program.
The best way to set a file descriptor ``close-on-exec'' is to create it in this state. To this end, the openfile function has O_CLOEXEC and O_KEEPEXEC flags to enforce ``close-on-exec'' mode or ``keep-on-exec'' mode, respectively. All other operations in the Unix module that create file descriptors have an optional argument ?cloexec:bool to indicate whether the file descriptor should be created in ``close-on-exec'' mode (by writing ~cloexec:true) or in ``keep-on-exec'' mode (by writing ~cloexec:false). For historical reasons, the default file descriptor creation mode is ``keep-on-exec'', if no cloexec optional argument is given. This is not a safe default, hence it is highly recommended to pass explicit cloexec arguments to operations that create file descriptors.
The cloexec optional arguments and the O_KEEPEXEC flag were introduced in OCaml 4.05. Earlier, the common practice was to create file descriptors in the default, ``keep-on-exec'' mode, then call set_close_on_exec on those freshly-created file descriptors. This is not as safe as creating the file descriptor in ``close-on-exec'' mode because, in multithreaded programs, a window of vulnerability exists between the time when the file descriptor is created and the time set_close_on_exec completes. If another thread spawns another program during this window, the descriptor will leak, as it is still in the ``keep-on-exec'' mode.
Regarding the atomicity guarantees given by ~cloexec:true or by the use of the O_CLOEXEC flag: on all platforms it is guaranteed that a concurrently-executing Caml thread cannot leak the descriptor by starting a new process. On Linux, this guarantee extends to concurrently-executing C threads. As of Feb 2017, other operating systems lack the necessary system calls and still expose a window of vulnerability during which a C thread can see the newly-created file descriptor in ``keep-on-exec'' mode.
val clear_close_on_exec : file_descr -> unitClear the ``close-on-exec'' flag on the given descriptor. See set_close_on_exec.
val opendir : string -> dir_handleOpen a descriptor on a directory
val readdir : dir_handle -> stringReturn the next entry in a directory.
val rewinddir : dir_handle -> unitReposition the descriptor to the beginning of the directory
val closedir : dir_handle -> unitClose a directory descriptor.
val pipe : ?cloexec:bool -> unit -> file_descr * file_descrCreate a pipe. The first component of the result is opened for reading, that's the exit to the pipe. The second component is opened for writing, that's the entrance to the pipe. See set_close_on_exec for documentation on the cloexec optional argument.
val create_process :
+ string ->
+ string array ->
+ file_descr ->
+ file_descr ->
+ file_descr ->
+ intcreate_process prog args stdin stdout stderr forks a new process that executes the program in file prog, with arguments args. The pid of the new process is returned immediately; the new process executes concurrently with the current process. The standard input and outputs of the new process are connected to the descriptors stdin, stdout and stderr. Passing e.g. Unix.stdout for stdout prevents the redirection and causes the new process to have the same standard output as the current process. The executable file prog is searched in the path. The new process has the same environment as the current process.
val create_process_env :
+ string ->
+ string array ->
+ string array ->
+ file_descr ->
+ file_descr ->
+ file_descr ->
+ intcreate_process_env prog args env stdin stdout stderr works as create_process, except that the extra argument env specifies the environment passed to the program.
val open_process_in : string -> in_channelHigh-level pipe and process management. This function runs the given command in parallel with the program. The standard output of the command is redirected to a pipe, which can be read via the returned input channel. The command is interpreted by the shell /bin/sh (or cmd.exe on Windows), cf. system. The Filename.quote_command function can be used to quote the command and its arguments as appropriate for the shell being used. If the command does not need to be run through the shell, open_process_args_in can be used as a more robust and more efficient alternative to open_process_in.
val open_process_out : string -> out_channelSame as open_process_in, but redirect the standard input of the command to a pipe. Data written to the returned output channel is sent to the standard input of the command. Warning: writes on output channels are buffered, hence be careful to call Stdlib.flush at the right times to ensure correct synchronization. If the command does not need to be run through the shell, open_process_args_out can be used instead of open_process_out.
val open_process : string -> in_channel * out_channelSame as open_process_out, but redirects both the standard input and standard output of the command to pipes connected to the two returned channels. The input channel is connected to the output of the command, and the output channel to the input of the command. If the command does not need to be run through the shell, open_process_args can be used instead of open_process.
val open_process_full :
+ string ->
+ string array ->
+ in_channel * out_channel * in_channelSimilar to open_process, but the second argument specifies the environment passed to the command. The result is a triple of channels connected respectively to the standard output, standard input, and standard error of the command. If the command does not need to be run through the shell, open_process_args_full can be used instead of open_process_full.
val open_process_args_in : string -> string array -> in_channelopen_process_args_in prog args runs the program prog with arguments args. The new process executes concurrently with the current process. The standard output of the new process is redirected to a pipe, which can be read via the returned input channel.
The executable file prog is searched in the path. This behaviour changed in 4.12; previously prog was looked up only in the current directory.
The new process has the same environment as the current process.
val open_process_args_out : string -> string array -> out_channelSame as open_process_args_in, but redirect the standard input of the new process to a pipe. Data written to the returned output channel is sent to the standard input of the program. Warning: writes on output channels are buffered, hence be careful to call Stdlib.flush at the right times to ensure correct synchronization.
val open_process_args : string -> string array -> in_channel * out_channelSame as open_process_args_out, but redirects both the standard input and standard output of the new process to pipes connected to the two returned channels. The input channel is connected to the output of the program, and the output channel to the input of the program.
val open_process_args_full :
+ string ->
+ string array ->
+ string array ->
+ in_channel * out_channel * in_channelSimilar to open_process_args, but the third argument specifies the environment passed to the new process. The result is a triple of channels connected respectively to the standard output, standard input, and standard error of the program.
val process_in_pid : in_channel -> intReturn the pid of a process opened via open_process_in or open_process_args_in.
val process_out_pid : out_channel -> intReturn the pid of a process opened via open_process_out or open_process_args_out.
val process_pid : (in_channel * out_channel) -> intReturn the pid of a process opened via open_process or open_process_args.
val process_full_pid : (in_channel * out_channel * in_channel) -> intReturn the pid of a process opened via open_process_full or open_process_args_full.
val close_process_in : in_channel -> process_statusClose channels opened by open_process_in, wait for the associated command to terminate, and return its termination status.
val close_process_out : out_channel -> process_statusClose channels opened by open_process_out, wait for the associated command to terminate, and return its termination status.
val close_process : (in_channel * out_channel) -> process_statusClose channels opened by open_process, wait for the associated command to terminate, and return its termination status.
val close_process_full :
+ (in_channel * out_channel * in_channel) ->
+ process_statusClose channels opened by open_process_full, wait for the associated command to terminate, and return its termination status.
symlink ?to_dir src dst creates the file dst as a symbolic link to the file src. On Windows, ~to_dir indicates if the symbolic link points to a directory or a file; if omitted, symlink examines src using stat and picks appropriately, if src does not exist then false is assumed (for this reason, it is recommended that the ~to_dir parameter be specified in new code). On Unix, ~to_dir is ignored.
Windows symbolic links are available in Windows Vista onwards. There are some important differences between Windows symlinks and their POSIX counterparts.
Windows symbolic links come in two flavours: directory and regular, which designate whether the symbolic link points to a directory or a file. The type must be correct - a directory symlink which actually points to a file cannot be selected with chdir and a file symlink which actually points to a directory cannot be read or written (note that Cygwin's emulation layer ignores this distinction).
When symbolic links are created to existing targets, this distinction doesn't matter and symlink will automatically create the correct kind of symbolic link. The distinction matters when a symbolic link is created to a non-existent target.
The other caveat is that by default symbolic links are a privileged operation. Administrators will always need to be running elevated (or with UAC disabled) and by default normal user accounts need to be granted the SeCreateSymbolicLinkPrivilege via Local Security Policy (secpol.msc) or via Active Directory.
has_symlink can be used to check that a process is able to create symbolic links.
Returns true if the user is able to create symbolic links. On Windows, this indicates that the user not only has the SeCreateSymbolicLinkPrivilege but is also running elevated, if necessary. On other platforms, this is simply indicates that the symlink system call is available.
val select :
+ file_descr list ->
+ file_descr list ->
+ file_descr list ->
+ float ->
+ file_descr list * file_descr list * file_descr listWait until some input/output operations become possible on some channels. The three list arguments are, respectively, a set of descriptors to check for reading (first argument), for writing (second argument), or for exceptional conditions (third argument). The fourth argument is the maximal timeout, in seconds; a negative fourth argument means no timeout (unbounded wait). The result is composed of three sets of descriptors: those ready for reading (first component), ready for writing (second component), and over which an exceptional condition is pending (third component).
type lock_command = | F_ULOCKUnlock a region
*)| F_LOCKLock a region for writing, and block if already locked
*)| F_TLOCKLock a region for writing, or fail if already locked
*)| F_TESTTest a region for other process locks
*)| F_RLOCKLock a region for reading, and block if already locked
*)| F_TRLOCKLock a region for reading, or fail if already locked
*)Commands for lockf.
val lockf : file_descr -> lock_command -> int -> unitlockf fd mode len puts a lock on a region of the file opened as fd. The region starts at the current read/write position for fd (as set by lseek), and extends len bytes forward if len is positive, len bytes backwards if len is negative, or to the end of the file if len is zero. A write lock prevents any other process from acquiring a read or write lock on the region. A read lock prevents any other process from acquiring a write lock on the region, but lets other processes acquire read locks on it.
The F_LOCK and F_TLOCK commands attempts to put a write lock on the specified region. The F_RLOCK and F_TRLOCK commands attempts to put a read lock on the specified region. If one or several locks put by another process prevent the current process from acquiring the lock, F_LOCK and F_RLOCK block until these locks are removed, while F_TLOCK and F_TRLOCK fail immediately with an exception. The F_ULOCK removes whatever locks the current process has on the specified region. Finally, the F_TEST command tests whether a write lock can be acquired on the specified region, without actually putting a lock. It returns immediately if successful, or fails otherwise.
What happens when a process tries to lock a region of a file that is already locked by the same process depends on the OS. On POSIX-compliant systems, the second lock operation succeeds and may "promote" the older lock from read lock to write lock. On Windows, the second lock operation will block or fail.
Note: installation of signal handlers is performed via the functions Sys.signal and Sys.set_signal.
kill pid signal sends signal number signal to the process with id pid.
On Windows: only the Sys.sigkill signal is emulated.
val sigprocmask : sigprocmask_command -> int list -> int listsigprocmask mode sigs changes the set of blocked signals. If mode is SIG_SETMASK, blocked signals are set to those in the list sigs. If mode is SIG_BLOCK, the signals in sigs are added to the set of blocked signals. If mode is SIG_UNBLOCK, the signals in sigs are removed from the set of blocked signals. sigprocmask returns the set of previously blocked signals.
When the systhreads version of the Thread module is loaded, this function redirects to Thread.sigmask. I.e., sigprocmask only changes the mask of the current thread.
sigsuspend sigs atomically sets the blocked signals to sigs and waits for a non-ignored, non-blocked signal to be delivered. On return, the blocked signals are reset to their initial value.
type process_times = {tms_utime : float;User time for the process
*)tms_stime : float;System time for the process
*)tms_cutime : float;User time for the children processes
*)tms_cstime : float;System time for the children processes
*)}The execution times (CPU times) of a process.
type tm = {tm_sec : int;Seconds 0..60
*)tm_min : int;Minutes 0..59
*)tm_hour : int;Hours 0..23
*)tm_mday : int;Day of month 1..31
*)tm_mon : int;Month of year 0..11
*)tm_year : int;Year - 1900
*)tm_wday : int;Day of week (Sunday is 0)
*)tm_yday : int;Day of year 0..365
*)tm_isdst : bool;Daylight time savings in effect
*)}The type representing wallclock time and calendar date.
Same as time, but with resolution better than 1 second.
val gmtime : float -> tmval localtime : float -> tmConvert a date and time, specified by the tm argument, into a time in seconds, as returned by time. The tm_isdst, tm_wday and tm_yday fields of tm are ignored. Also return a normalized copy of the given tm record, with the tm_wday, tm_yday, and tm_isdst fields recomputed from the other fields, and the other fields normalized (so that, e.g., 40 October is changed into 9 November). The tm argument is interpreted in the local time zone.
Stop execution for the given number of seconds. Like sleep, but fractions of seconds are supported.
val times : unit -> process_timesReturn the execution times of the process.
On Windows: partially implemented, will not report timings for child processes.
Set the last access time (second arg) and last modification time (third arg) for a file. Times are expressed in seconds from 00:00:00 GMT, Jan. 1, 1970. If both times are 0.0, the access and last modification times are both set to the current time.
type interval_timer = | ITIMER_REALdecrements in real time, and sends the signal SIGALRM when expired.
| ITIMER_VIRTUALdecrements in process virtual time, and sends SIGVTALRM when expired.
| ITIMER_PROF(for profiling) decrements both when the process is running and when the system is running on behalf of the process; it sends SIGPROF when expired.
The three kinds of interval timers.
val getitimer : interval_timer -> interval_timer_statusReturn the current status of the given interval timer.
val setitimer :
+ interval_timer ->
+ interval_timer_status ->
+ interval_timer_statussetitimer t s sets the interval timer t and returns its previous status. The s argument is interpreted as follows: s.it_value, if nonzero, is the time to the next timer expiration; s.it_interval, if nonzero, specifies a value to be used in reloading it_value when the timer expires. Setting s.it_value to zero disables the timer. Setting s.it_interval to zero causes the timer to be disabled after its next expiration.
Return the user id of the user executing the process.
On Windows: always returns 1.
Return the effective user id under which the process runs.
On Windows: always returns 1.
Return the group id of the user executing the process.
On Windows: always returns 1.
Return the effective group id under which the process runs.
On Windows: always returns 1.
Return the list of groups to which the user executing the process belongs.
On Windows: always returns [|1|].
setgroups groups sets the supplementary group IDs for the calling process. Appropriate privileges are required.
initgroups user group initializes the group access list by reading the group database /etc/group and using all groups of which user is a member. The additional group group is also added to the list.
type passwd_entry = {pw_name : string;pw_passwd : string;pw_uid : int;pw_gid : int;pw_gecos : string;pw_dir : string;pw_shell : string;}Structure of entries in the passwd database.
Structure of entries in the groups database.
val getpwnam : string -> passwd_entryFind an entry in passwd with the given name.
val getgrnam : string -> group_entryFind an entry in group with the given name.
val getpwuid : int -> passwd_entryFind an entry in passwd with the given user id.
val getgrgid : int -> group_entryFind an entry in group with the given group id.
val inet_addr_of_string : string -> inet_addrConversion from the printable representation of an Internet address to its internal representation. The argument string consists of 4 numbers separated by periods (XXX.YYY.ZZZ.TTT) for IPv4 addresses, and up to 8 numbers separated by colons for IPv6 addresses.
val string_of_inet_addr : inet_addr -> stringReturn the printable representation of the given Internet address. See inet_addr_of_string for a description of the printable representation.
val inet_addr_any : inet_addrA special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
val inet_addr_loopback : inet_addrA special IPv4 address representing the host machine (127.0.0.1).
val inet6_addr_any : inet_addrA special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
val inet6_addr_loopback : inet_addrA special IPv6 address representing the host machine (::1).
val is_inet6_addr : inet_addr -> boolWhether the given inet_addr is an IPv6 address.
The type of socket domains. Not all platforms support IPv6 sockets (type PF_INET6).
On Windows: PF_UNIX supported since 4.14.0 on Windows 10 1803 and later.
The type of socket kinds, specifying the semantics of communications. SOCK_SEQPACKET is included for completeness, but is rarely supported by the OS, and needs system calls that are not available in this library.
The type of socket addresses. ADDR_UNIX name is a socket address in the Unix domain; name is a file name in the file system. ADDR_INET(addr,port) is a socket address in the Internet domain; addr is the Internet address of the machine, and port is the port number.
val socket : ?cloexec:bool -> socket_domain -> socket_type -> int -> file_descrCreate a new socket in the given domain, and with the given kind. The third argument is the protocol type; 0 selects the default protocol for that kind of sockets. See set_close_on_exec for documentation on the cloexec optional argument.
val domain_of_sockaddr : sockaddr -> socket_domainReturn the socket domain adequate for the given socket address.
val socketpair :
+ ?cloexec:bool ->
+ socket_domain ->
+ socket_type ->
+ int ->
+ file_descr * file_descrCreate a pair of unnamed sockets, connected together. See set_close_on_exec for documentation on the cloexec optional argument.
val accept : ?cloexec:bool -> file_descr -> file_descr * sockaddrAccept connections on the given socket. The returned descriptor is a socket connected to the client; the returned address is the address of the connecting client. See set_close_on_exec for documentation on the cloexec optional argument.
val bind : file_descr -> sockaddr -> unitBind a socket to an address.
val connect : file_descr -> sockaddr -> unitConnect a socket to an address.
val listen : file_descr -> int -> unitSet up a socket for receiving connection requests. The integer argument is the maximal number of pending requests.
val shutdown : file_descr -> shutdown_command -> unitShutdown a socket connection. SHUTDOWN_SEND as second argument causes reads on the other end of the connection to return an end-of-file condition. SHUTDOWN_RECEIVE causes writes on the other end of the connection to return a closed pipe condition (SIGPIPE signal).
val getsockname : file_descr -> sockaddrReturn the address of the given socket.
val getpeername : file_descr -> sockaddrReturn the address of the host connected to the given socket.
val recv : file_descr -> bytes -> int -> int -> msg_flag list -> intReceive data from a connected socket.
val recvfrom :
+ file_descr ->
+ bytes ->
+ int ->
+ int ->
+ msg_flag list ->
+ int * sockaddrReceive data from an unconnected socket.
val send : file_descr -> bytes -> int -> int -> msg_flag list -> intSend data over a connected socket.
val send_substring : file_descr -> string -> int -> int -> msg_flag list -> intSame as send, but take the data from a string instead of a byte sequence.
val sendto :
+ file_descr ->
+ bytes ->
+ int ->
+ int ->
+ msg_flag list ->
+ sockaddr ->
+ intSend data over an unconnected socket.
val sendto_substring :
+ file_descr ->
+ string ->
+ int ->
+ int ->
+ msg_flag list ->
+ sockaddr ->
+ intSame as sendto, but take the data from a string instead of a byte sequence.
type socket_bool_option = | SO_DEBUGRecord debugging information
*)| SO_BROADCASTPermit sending of broadcast messages
*)| SO_REUSEADDRAllow reuse of local addresses for bind
*)| SO_KEEPALIVEKeep connection active
*)| SO_DONTROUTEBypass the standard routing algorithms
*)| SO_OOBINLINELeave out-of-band data in line
*)| SO_ACCEPTCONNReport whether socket listening is enabled
*)| TCP_NODELAYControl the Nagle algorithm for TCP sockets
*)| IPV6_ONLYForbid binding an IPv6 socket to an IPv4 address
*)| SO_REUSEPORTAllow reuse of address and port bindings
*)The socket options that can be consulted with getsockopt and modified with setsockopt. These options have a boolean (true/false) value.
The socket options that can be consulted with getsockopt_int and modified with setsockopt_int. These options have an integer value.
The socket options that can be consulted with getsockopt_optint and modified with setsockopt_optint. These options have a value of type int option, with None meaning ``disabled''.
The socket options that can be consulted with getsockopt_float and modified with setsockopt_float. These options have a floating-point value representing a time in seconds. The value 0 means infinite timeout.
val getsockopt : file_descr -> socket_bool_option -> boolReturn the current status of a boolean-valued option in the given socket.
val setsockopt : file_descr -> socket_bool_option -> bool -> unitSet or clear a boolean-valued option in the given socket.
val getsockopt_int : file_descr -> socket_int_option -> intSame as getsockopt for an integer-valued socket option.
val setsockopt_int : file_descr -> socket_int_option -> int -> unitSame as setsockopt for an integer-valued socket option.
val getsockopt_optint : file_descr -> socket_optint_option -> int optionSame as getsockopt for a socket option whose value is an int option.
val setsockopt_optint :
+ file_descr ->
+ socket_optint_option ->
+ int option ->
+ unitSame as setsockopt for a socket option whose value is an int option.
val getsockopt_float : file_descr -> socket_float_option -> floatSame as getsockopt for a socket option whose value is a floating-point number.
val setsockopt_float : file_descr -> socket_float_option -> float -> unitSame as setsockopt for a socket option whose value is a floating-point number.
val getsockopt_error : file_descr -> error optionReturn the error condition associated with the given socket, and clear it.
val open_connection : sockaddr -> in_channel * out_channelConnect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call Stdlib.flush on the output channel at the right times to ensure correct synchronization.
The two channels returned by open_connection share a descriptor to a socket. Therefore, when the connection is over, you should call Stdlib.close_out on the output channel, which will also close the underlying socket. Do not call Stdlib.close_in on the input channel; it will be collected by the GC eventually.
val shutdown_connection : in_channel -> unit``Shut down'' a connection established with open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection. This does not close the socket and the channels used by the connection. See Unix.open_connection for how to close them once the connection is over.
val establish_server : (in_channel -> out_channel -> unit) -> sockaddr -> unitEstablish a server on the given address. The function given as first argument is called for each connection with two buffered channels connected to the client. A new process is created for each connection. The function establish_server never returns normally.
The two channels given to the function share a descriptor to a socket. The function does not need to close the channels, since this occurs automatically when the function returns. If the function prefers explicit closing, it should close the output channel using Stdlib.close_out and leave the input channel unclosed, for reasons explained in Unix.in_channel_of_descr.
type host_entry = {h_name : string;h_aliases : string array;h_addrtype : socket_domain;h_addr_list : inet_addr array;}Structure of entries in the hosts database.
Structure of entries in the protocols database.
Structure of entries in the services database.
val gethostbyname : string -> host_entryFind an entry in hosts with the given name.
val gethostbyaddr : inet_addr -> host_entryFind an entry in hosts with the given address.
val getprotobyname : string -> protocol_entryFind an entry in protocols with the given name.
val getprotobynumber : int -> protocol_entryFind an entry in protocols with the given protocol number.
val getservbyname : string -> string -> service_entryFind an entry in services with the given name.
val getservbyport : int -> string -> service_entryFind an entry in services with the given service number.
type addr_info = {ai_family : socket_domain;Socket domain
*)ai_socktype : socket_type;Socket type
*)ai_protocol : int;Socket protocol number
*)ai_addr : sockaddr;Address
*)ai_canonname : string;Canonical host name
*)}Address information returned by getaddrinfo.
type getaddrinfo_option = | AI_FAMILY of socket_domainImpose the given socket domain
*)| AI_SOCKTYPE of socket_typeImpose the given socket type
*)| AI_PROTOCOL of intImpose the given protocol
*)| AI_NUMERICHOSTDo not call name resolver, expect numeric IP address
*)| AI_CANONNAMEFill the ai_canonname field of the result
| AI_PASSIVEOptions to getaddrinfo.
val getaddrinfo : string -> string -> getaddrinfo_option list -> addr_info listgetaddrinfo host service opts returns a list of addr_info records describing socket parameters and addresses suitable for communicating with the given host and service. The empty list is returned if the host or service names are unknown, or the constraints expressed in opts cannot be satisfied.
host is either a host name or the string representation of an IP address. host can be given as the empty string; in this case, the ``any'' address or the ``loopback'' address are used, depending whether opts contains AI_PASSIVE. service is either a service name or the string representation of a port number. service can be given as the empty string; in this case, the port field of the returned addresses is set to 0. opts is a possibly empty list of options that allows the caller to force a particular socket domain (e.g. IPv6 only or IPv4 only) or a particular socket type (e.g. TCP only or UDP only).
type name_info = {ni_hostname : string;Name or IP address of host
*)ni_service : string;Name of service or port number
*)}Host and service information returned by getnameinfo.
Options to getnameinfo.
val getnameinfo : sockaddr -> getnameinfo_option list -> name_infogetnameinfo addr opts returns the host name and service name corresponding to the socket address addr. opts is a possibly empty list of options that governs how these names are obtained.
The following functions implement the POSIX standard terminal interface. They provide control over asynchronous communication ports and pseudo-terminals. Refer to the termios man page for a complete description.
type terminal_io = {mutable c_ignbrk : bool;Ignore the break condition.
*)mutable c_brkint : bool;Signal interrupt on break condition.
*)mutable c_ignpar : bool;Ignore characters with parity errors.
*)mutable c_parmrk : bool;Mark parity errors.
*)mutable c_inpck : bool;Enable parity check on input.
*)mutable c_istrip : bool;Strip 8th bit on input characters.
*)mutable c_inlcr : bool;Map NL to CR on input.
*)mutable c_igncr : bool;Ignore CR on input.
*)mutable c_icrnl : bool;Map CR to NL on input.
*)mutable c_ixon : bool;Recognize XON/XOFF characters on input.
*)mutable c_ixoff : bool;Emit XON/XOFF chars to control input flow.
*)mutable c_opost : bool;Enable output processing.
*)mutable c_obaud : int;Output baud rate (0 means close connection).
*)mutable c_ibaud : int;Input baud rate.
*)mutable c_csize : int;Number of bits per character (5-8).
*)mutable c_cstopb : int;Number of stop bits (1-2).
*)mutable c_cread : bool;Reception is enabled.
*)mutable c_parenb : bool;Enable parity generation and detection.
*)mutable c_parodd : bool;Specify odd parity instead of even.
*)mutable c_hupcl : bool;Hang up on last close.
*)mutable c_clocal : bool;Ignore modem status lines.
*)mutable c_isig : bool;Generate signal on INTR, QUIT, SUSP.
*)mutable c_icanon : bool;Enable canonical processing (line buffering and editing)
*)mutable c_noflsh : bool;Disable flush after INTR, QUIT, SUSP.
*)mutable c_echo : bool;Echo input characters.
*)mutable c_echoe : bool;Echo ERASE (to erase previous character).
*)mutable c_echok : bool;Echo KILL (to erase the current line).
*)mutable c_echonl : bool;Echo NL even if c_echo is not set.
*)mutable c_vintr : char;Interrupt character (usually ctrl-C).
*)mutable c_vquit : char;Quit character (usually ctrl-\).
*)mutable c_verase : char;Erase character (usually DEL or ctrl-H).
*)mutable c_vkill : char;Kill line character (usually ctrl-U).
*)mutable c_veof : char;End-of-file character (usually ctrl-D).
*)mutable c_veol : char;Alternate end-of-line char. (usually none).
*)mutable c_vmin : int;Minimum number of characters to read before the read request is satisfied.
*)mutable c_vtime : int;Maximum read wait (in 0.1s units).
*)mutable c_vstart : char;Start character (usually ctrl-Q).
*)mutable c_vstop : char;Stop character (usually ctrl-S).
*)}val tcgetattr : file_descr -> terminal_ioReturn the status of the terminal referred to by the given file descriptor.
val tcsetattr : file_descr -> setattr_when -> terminal_io -> unitSet the status of the terminal referred to by the given file descriptor. The second argument indicates when the status change takes place: immediately (TCSANOW), when all pending output has been transmitted (TCSADRAIN), or after flushing all input that has been received but not read (TCSAFLUSH). TCSADRAIN is recommended when changing the output parameters; TCSAFLUSH, when changing the input parameters.
val tcsendbreak : file_descr -> int -> unitSend a break condition on the given file descriptor. The second argument is the duration of the break, in 0.1s units; 0 means standard duration (0.25s).
val tcdrain : file_descr -> unitWaits until all output written on the given file descriptor has been transmitted.
val tcflush : file_descr -> flush_queue -> unitDiscard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: TCIFLUSH flushes data received but not read, TCOFLUSH flushes data written but not transmitted, and TCIOFLUSH flushes both.
val tcflow : file_descr -> flow_action -> unitSuspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: TCOOFF suspends output, TCOON restarts output, TCIOFF transmits a STOP character to suspend input, and TCION transmits a START character to restart input.
UnixLabels.LargeFileFile operations on large files. This sub-module provides 64-bit variants of the functions lseek (for positioning a file descriptor), truncate and ftruncate (for changing the size of a file), and stat, lstat and fstat (for obtaining information on files). These alternate functions represent positions and sizes by 64-bit integers (type int64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
val lseek : file_descr -> int64 -> mode:seek_command -> int64See lseek.
val ftruncate : file_descr -> len:int64 -> unitSee ftruncate.
type stats = Unix.LargeFile.stats = {st_dev : int;Device number
*)st_ino : int;Inode number
*)st_kind : file_kind;Kind of the file
*)st_perm : file_perm;Access rights
*)st_nlink : int;Number of links
*)st_uid : int;User id of the owner
*)st_gid : int;Group ID of the file's group
*)st_rdev : int;Device ID (if special file)
*)st_size : int64;Size in bytes
*)st_atime : float;Last access time
*)st_mtime : float;Last modification time
*)st_ctime : float;Last status change time
*)}val stat : string -> statsval lstat : string -> statsval fstat : file_descr -> statsUnixLabelsInterface to the Unix system.
To use the labeled version of this module, add module Unix = UnixLabels in your implementation.
Note: all the functions of this module (except error_message and handle_unix_error) are liable to raise the Unix_error exception whenever the underlying system call signals an error.
type error = Unix.error = | E2BIGArgument list too long
*)| EACCESPermission denied
*)| EAGAINResource temporarily unavailable; try again
*)| EBADFBad file descriptor
*)| EBUSYResource unavailable
*)| ECHILDNo child process
*)| EDEADLKResource deadlock would occur
*)| EDOMDomain error for math functions, etc.
*)| EEXISTFile exists
*)| EFAULTBad address
*)| EFBIGFile too large
*)| EINTRFunction interrupted by signal
*)| EINVALInvalid argument
*)| EIOHardware I/O error
*)| EISDIRIs a directory
*)| EMFILEToo many open files by the process
*)| EMLINKToo many links
*)| ENAMETOOLONGFilename too long
*)| ENFILEToo many open files in the system
*)| ENODEVNo such device
*)| ENOENTNo such file or directory
*)| ENOEXECNot an executable file
*)| ENOLCKNo locks available
*)| ENOMEMNot enough memory
*)| ENOSPCNo space left on device
*)| ENOSYSFunction not supported
*)| ENOTDIRNot a directory
*)| ENOTEMPTYDirectory not empty
*)| ENOTTYInappropriate I/O control operation
*)| ENXIONo such device or address
*)| EPERMOperation not permitted
*)| EPIPEBroken pipe
*)| ERANGEResult too large
*)| EROFSRead-only file system
*)| ESPIPEInvalid seek e.g. on a pipe
*)| ESRCHNo such process
*)| EXDEVInvalid link
*)| EWOULDBLOCKOperation would block
*)| EINPROGRESSOperation now in progress
*)| EALREADYOperation already in progress
*)| ENOTSOCKSocket operation on non-socket
*)| EDESTADDRREQDestination address required
*)| EMSGSIZEMessage too long
*)| EPROTOTYPEProtocol wrong type for socket
*)| ENOPROTOOPTProtocol not available
*)| EPROTONOSUPPORTProtocol not supported
*)| ESOCKTNOSUPPORTSocket type not supported
*)| EOPNOTSUPPOperation not supported on socket
*)| EPFNOSUPPORTProtocol family not supported
*)| EAFNOSUPPORTAddress family not supported by protocol family
*)| EADDRINUSEAddress already in use
*)| EADDRNOTAVAILCan't assign requested address
*)| ENETDOWNNetwork is down
*)| ENETUNREACHNetwork is unreachable
*)| ENETRESETNetwork dropped connection on reset
*)| ECONNABORTEDSoftware caused connection abort
*)| ECONNRESETConnection reset by peer
*)| ENOBUFSNo buffer space available
*)| EISCONNSocket is already connected
*)| ENOTCONNSocket is not connected
*)| ESHUTDOWNCan't send after socket shutdown
*)| ETOOMANYREFSToo many references: can't splice
*)| ETIMEDOUTConnection timed out
*)| ECONNREFUSEDConnection refused
*)| EHOSTDOWNHost is down
*)| EHOSTUNREACHNo route to host
*)| ELOOPToo many levels of symbolic links
*)| EOVERFLOWFile size or position not representable
*)| EUNKNOWNERR of intUnknown error
*)The type of error codes. Errors defined in the POSIX standard and additional errors from UNIX98 and BSD. All other errors are mapped to EUNKNOWNERR.
exception Unix_error of error * string * stringRaised by the system calls below when an error is encountered. The first component is the error code; the second component is the function name; the third component is the string parameter to the function, if it has one, or the empty string otherwise.
UnixLabels.Unix_error and Unix.Unix_error are the same, and catching one will catch the other.
val error_message : error -> stringReturn a string describing the given error code.
handle_unix_error f x applies f to x and returns the result. If the exception Unix_error is raised, it prints a message describing the error and exits with code 2.
Return the process environment, as an array of strings with the format ``variable=value''. The returned array is empty if the process has special privileges.
Return the process environment, as an array of strings with the format ``variable=value''. Unlike environment, this function returns a populated array even if the process has special privileges. See the documentation for unsafe_getenv for more details.
Return the value associated to a variable in the process environment, unless the process has special privileges.
Return the value associated to a variable in the process environment.
Unlike getenv, this function returns the value even if the process has special privileges. It is considered unsafe because the programmer of a setuid or setgid program must be careful to avoid using maliciously crafted environment variables in the search path for executables, the locations for temporary files or logs, and the like.
putenv name value sets the value associated to a variable in the process environment. name is the name of the environment variable, and value its new associated value.
type process_status = Unix.process_status = The termination status of a process. See module Sys for the definitions of the standard signal numbers. Note that they are not the numbers used by the OS.
type wait_flag = Unix.wait_flag = Flags for waitpid.
execv ~prog ~args execute the program in file prog, with the arguments args, and the current process environment. These execv* functions never return: on success, the current program is replaced by the new one.
Same as execv, except that the third argument provides the environment to the program executed.
Same as execv, except that the program is searched in the path.
Same as execve, except that the program is searched in the path.
Fork a new process. The returned integer is 0 for the child process, the pid of the child process for the parent process.
val wait : unit -> int * process_statusWait until one of the children processes die, and return its pid and termination status.
val waitpid : mode:wait_flag list -> int -> int * process_statusSame as wait, but waits for the child process whose pid is given. A pid of -1 means wait for any child. A pid of 0 means wait for any child in the same process group as the current process. Negative pid arguments represent process groups. The list of options indicates whether waitpid should return immediately without waiting, and whether it should report stopped children.
On Windows: can only wait for a given PID, not any child process.
val system : string -> process_statusExecute the given command, wait until it terminates, and return its termination status. The string is interpreted by the shell /bin/sh (or the command interpreter cmd.exe on Windows) and therefore can contain redirections, quotes, variables, etc. To properly quote whitespace and shell special characters occurring in file names or command arguments, the use of Filename.quote_command is recommended. The result WEXITED 127 indicates that the shell couldn't be executed.
Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. Unlike Stdlib.exit, Unix._exit performs no finalization whatsoever: functions registered with Stdlib.at_exit are not called, input/output channels are not flushed, and the C run-time system is not finalized either.
The typical use of Unix._exit is after a Unix.fork operation, when the child process runs into a fatal error and must exit. In this case, it is preferable to not perform any finalization action in the child process, as these actions could interfere with similar actions performed by the parent process. For example, output channels should not be flushed by the child process, as the parent process may flush them again later, resulting in duplicate output.
Change the process priority. The integer argument is added to the ``nice'' value. (Higher values of the ``nice'' value mean lower priorities.) Return the new nice value.
type file_descr = Unix.file_descrThe abstract type of file descriptors.
val stdin : file_descrFile descriptor for standard input.
val stdout : file_descrFile descriptor for standard output.
val stderr : file_descrFile descriptor for standard error.
type open_flag = Unix.open_flag = | O_RDONLYOpen for reading
*)| O_WRONLYOpen for writing
*)| O_RDWROpen for reading and writing
*)| O_NONBLOCKOpen in non-blocking mode
*)| O_APPENDOpen for append
*)| O_CREATCreate if nonexistent
*)| O_TRUNCTruncate to 0 length if existing
*)| O_EXCLFail if existing
*)| O_NOCTTYDon't make this dev a controlling tty
*)| O_DSYNCWrites complete as `Synchronised I/O data integrity completion'
*)| O_SYNCWrites complete as `Synchronised I/O file integrity completion'
*)| O_RSYNCReads complete as writes (depending on O_SYNC/O_DSYNC)
*)| O_SHARE_DELETEWindows only: allow the file to be deleted while still open
*)| O_CLOEXECSet the close-on-exec flag on the descriptor returned by openfile. See set_close_on_exec for more information.
| O_KEEPEXECClear the close-on-exec flag. This is currently the default.
*)The flags to openfile.
The type of file access rights, e.g. 0o640 is read and write for user, read for group, none for others
val openfile : string -> mode:open_flag list -> perm:file_perm -> file_descrOpen the named file with the given flags. Third argument is the permissions to give to the file if it is created (see umask). Return a file descriptor on the named file.
val close : file_descr -> unitClose a file descriptor.
val fsync : file_descr -> unitFlush file buffers to disk.
val read : file_descr -> buf:bytes -> pos:int -> len:int -> intread fd ~buf ~pos ~len reads len bytes from descriptor fd, storing them in byte sequence buf, starting at position pos in buf. Return the number of bytes actually read.
val write : file_descr -> buf:bytes -> pos:int -> len:int -> intwrite fd ~buf ~pos ~len writes len bytes to descriptor fd, taking them from byte sequence buf, starting at position pos in buff. Return the number of bytes actually written. write repeats the writing operation until all bytes have been written or an error occurs.
val single_write : file_descr -> buf:bytes -> pos:int -> len:int -> intSame as write, but attempts to write only once. Thus, if an error occurs, single_write guarantees that no data has been written.
val write_substring : file_descr -> buf:string -> pos:int -> len:int -> intSame as write, but take the data from a string instead of a byte sequence.
val single_write_substring :
+ file_descr ->
+ buf:string ->
+ pos:int ->
+ len:int ->
+ intSame as single_write, but take the data from a string instead of a byte sequence.
val in_channel_of_descr : file_descr -> in_channelCreate an input channel reading from the given descriptor. The channel is initially in binary mode; use set_binary_mode_in ic false if text mode is desired. Text mode is supported only if the descriptor refers to a file or pipe, but is not supported if it refers to a socket.
On Windows: Stdlib.set_binary_mode_in always fails on channels created with this function.
Beware that input channels are buffered, so more characters may have been read from the descriptor than those accessed using channel functions. Channels also keep a copy of the current position in the file.
Closing the channel ic returned by in_channel_of_descr fd using close_in ic also closes the underlying descriptor fd. It is incorrect to close both the channel ic and the descriptor fd.
If several channels are created on the same descriptor, one of the channels must be closed, but not the others. Consider for example a descriptor s connected to a socket and two channels ic = in_channel_of_descr s and oc = out_channel_of_descr s. The recommended closing protocol is to perform close_out oc, which flushes buffered output to the socket then closes the socket. The ic channel must not be closed and will be collected by the GC eventually.
val out_channel_of_descr : file_descr -> out_channelCreate an output channel writing on the given descriptor. The channel is initially in binary mode; use set_binary_mode_out oc false if text mode is desired. Text mode is supported only if the descriptor refers to a file or pipe, but is not supported if it refers to a socket.
On Windows: Stdlib.set_binary_mode_out always fails on channels created with this function.
Beware that output channels are buffered, so you may have to call Stdlib.flush to ensure that all data has been sent to the descriptor. Channels also keep a copy of the current position in the file.
Closing the channel oc returned by out_channel_of_descr fd using close_out oc also closes the underlying descriptor fd. It is incorrect to close both the channel ic and the descriptor fd.
See Unix.in_channel_of_descr for a discussion of the closing protocol when several channels are created on the same descriptor.
val descr_of_in_channel : in_channel -> file_descrReturn the descriptor corresponding to an input channel.
val descr_of_out_channel : out_channel -> file_descrReturn the descriptor corresponding to an output channel.
type seek_command = Unix.seek_command = Positioning modes for lseek.
val lseek : file_descr -> int -> mode:seek_command -> intSet the current position for a file descriptor, and return the resulting offset (from the beginning of the file).
val ftruncate : file_descr -> len:int -> unitTruncates the file corresponding to the given descriptor to the given size.
type file_kind = Unix.file_kind = type stats = Unix.stats = {st_dev : int;Device number
*)st_ino : int;Inode number
*)st_kind : file_kind;Kind of the file
*)st_perm : file_perm;Access rights
*)st_nlink : int;Number of links
*)st_uid : int;User id of the owner
*)st_gid : int;Group ID of the file's group
*)st_rdev : int;Device ID (if special file)
*)st_size : int;Size in bytes
*)st_atime : float;Last access time
*)st_mtime : float;Last modification time
*)st_ctime : float;Last status change time
*)}The information returned by the stat calls.
val stat : string -> statsReturn the information for the named file.
val lstat : string -> statsSame as stat, but in case the file is a symbolic link, return the information for the link itself.
val fstat : file_descr -> statsReturn the information for the file associated with the given descriptor.
val isatty : file_descr -> boolReturn true if the given file descriptor refers to a terminal or console window, false otherwise.
module LargeFile : sig ... endFile operations on large files. This sub-module provides 64-bit variants of the functions lseek (for positioning a file descriptor), truncate and ftruncate (for changing the size of a file), and stat, lstat and fstat (for obtaining information on files). These alternate functions represent positions and sizes by 64-bit integers (type int64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
val map_file :
+ file_descr ->
+ ?pos:int64 ->
+ kind:('a, 'b) Stdlib.Bigarray.kind ->
+ layout:'c Stdlib.Bigarray.layout ->
+ shared:bool ->
+ dims:int array ->
+ ('a, 'b, 'c) Stdlib.Bigarray.Genarray.tMemory mapping of a file as a Bigarray. map_file fd ~kind ~layout ~shared ~dims returns a Bigarray of kind kind, layout layout, and dimensions as specified in dims. The data contained in this Bigarray are the contents of the file referred to by the file descriptor fd (as opened previously with openfile, for example). The optional pos parameter is the byte offset in the file of the data being mapped; it defaults to 0 (map from the beginning of the file).
If shared is true, all modifications performed on the array are reflected in the file. This requires that fd be opened with write permissions. If shared is false, modifications performed on the array are done in memory only, using copy-on-write of the modified pages; the underlying file is not affected.
Genarray.map_file is much more efficient than reading the whole file in a Bigarray, modifying that Bigarray, and writing it afterwards.
To adjust automatically the dimensions of the Bigarray to the actual size of the file, the major dimension (that is, the first dimension for an array with C layout, and the last dimension for an array with Fortran layout) can be given as -1. Genarray.map_file then determines the major dimension from the size of the file. The file must contain an integral number of sub-arrays as determined by the non-major dimensions, otherwise Failure is raised.
If all dimensions of the Bigarray are given, the file size is matched against the size of the Bigarray. If the file is larger than the Bigarray, only the initial portion of the file is mapped to the Bigarray. If the file is smaller than the big array, the file is automatically grown to the size of the Bigarray. This requires write permissions on fd.
Array accesses are bounds-checked, but the bounds are determined by the initial call to map_file. Therefore, you should make sure no other process modifies the mapped file while you're accessing it, or a SIGBUS signal may be raised. This happens, for instance, if the file is shrunk.
Invalid_argument or Failure may be raised in cases where argument validation fails.
Removes the named file.
If the named file is a directory, raises:
EPERM on POSIX compliant systemEISDIR on Linux >= 2.1.132EACCESS on Windowsrename ~src ~dst changes the name of a file from src to dst, moving it between directories if needed. If dst already exists, its contents will be replaced with those of src. Depending on the operating system, the metadata (permissions, owner, etc) of dst can either be preserved or be replaced by those of src.
link ?follow ~src ~dst creates a hard link named dst to the file named src.
realpath p is an absolute pathname for p obtained by resolving all extra / characters, relative path segments and symbolic links.
type access_permission = Unix.access_permission = Flags for the access call.
val chmod : string -> perm:file_perm -> unitChange the permissions of the named file.
val fchmod : file_descr -> perm:file_perm -> unitChange the permissions of an opened file.
Change the owner uid and owner gid of the named file.
val fchown : file_descr -> uid:int -> gid:int -> unitChange the owner uid and owner gid of an opened file.
val access : string -> perm:access_permission list -> unitCheck that the process has the given permissions over the named file.
On Windows: execute permission X_OK cannot be tested, just tests for read permission instead.
val dup : ?cloexec:bool -> file_descr -> file_descrReturn a new file descriptor referencing the same file as the given descriptor. See set_close_on_exec for documentation on the cloexec optional argument.
val dup2 : ?cloexec:bool -> src:file_descr -> dst:file_descr -> unitdup2 ~src ~dst duplicates src to dst, closing dst if already opened. See set_close_on_exec for documentation on the cloexec optional argument.
val set_nonblock : file_descr -> unitSet the ``non-blocking'' flag on the given descriptor. When the non-blocking flag is set, reading on a descriptor on which there is temporarily no data available raises the EAGAIN or EWOULDBLOCK error instead of blocking; writing on a descriptor on which there is temporarily no room for writing also raises EAGAIN or EWOULDBLOCK.
val clear_nonblock : file_descr -> unitClear the ``non-blocking'' flag on the given descriptor. See set_nonblock.
val set_close_on_exec : file_descr -> unitSet the ``close-on-exec'' flag on the given descriptor. A descriptor with the close-on-exec flag is automatically closed when the current process starts another program with one of the exec, create_process and open_process functions.
It is often a security hole to leak file descriptors opened on, say, a private file to an external program: the program, then, gets access to the private file and can do bad things with it. Hence, it is highly recommended to set all file descriptors ``close-on-exec'', except in the very few cases where a file descriptor actually needs to be transmitted to another program.
The best way to set a file descriptor ``close-on-exec'' is to create it in this state. To this end, the openfile function has O_CLOEXEC and O_KEEPEXEC flags to enforce ``close-on-exec'' mode or ``keep-on-exec'' mode, respectively. All other operations in the Unix module that create file descriptors have an optional argument ?cloexec:bool to indicate whether the file descriptor should be created in ``close-on-exec'' mode (by writing ~cloexec:true) or in ``keep-on-exec'' mode (by writing ~cloexec:false). For historical reasons, the default file descriptor creation mode is ``keep-on-exec'', if no cloexec optional argument is given. This is not a safe default, hence it is highly recommended to pass explicit cloexec arguments to operations that create file descriptors.
The cloexec optional arguments and the O_KEEPEXEC flag were introduced in OCaml 4.05. Earlier, the common practice was to create file descriptors in the default, ``keep-on-exec'' mode, then call set_close_on_exec on those freshly-created file descriptors. This is not as safe as creating the file descriptor in ``close-on-exec'' mode because, in multithreaded programs, a window of vulnerability exists between the time when the file descriptor is created and the time set_close_on_exec completes. If another thread spawns another program during this window, the descriptor will leak, as it is still in the ``keep-on-exec'' mode.
Regarding the atomicity guarantees given by ~cloexec:true or by the use of the O_CLOEXEC flag: on all platforms it is guaranteed that a concurrently-executing Caml thread cannot leak the descriptor by starting a new process. On Linux, this guarantee extends to concurrently-executing C threads. As of Feb 2017, other operating systems lack the necessary system calls and still expose a window of vulnerability during which a C thread can see the newly-created file descriptor in ``keep-on-exec'' mode.
val clear_close_on_exec : file_descr -> unitClear the ``close-on-exec'' flag on the given descriptor. See set_close_on_exec.
val mkdir : string -> perm:file_perm -> unitCreate a directory with the given permissions (see umask).
type dir_handle = Unix.dir_handleThe type of descriptors over opened directories.
val opendir : string -> dir_handleOpen a descriptor on a directory
val readdir : dir_handle -> stringReturn the next entry in a directory.
val rewinddir : dir_handle -> unitReposition the descriptor to the beginning of the directory
val closedir : dir_handle -> unitClose a directory descriptor.
val pipe : ?cloexec:bool -> unit -> file_descr * file_descrCreate a pipe. The first component of the result is opened for reading, that's the exit to the pipe. The second component is opened for writing, that's the entrance to the pipe. See set_close_on_exec for documentation on the cloexec optional argument.
val mkfifo : string -> perm:file_perm -> unitCreate a named pipe with the given permissions (see umask).
val create_process :
+ prog:string ->
+ args:string array ->
+ stdin:file_descr ->
+ stdout:file_descr ->
+ stderr:file_descr ->
+ intcreate_process ~prog ~args ~stdin ~stdout ~stderr forks a new process that executes the program in file prog, with arguments args. The pid of the new process is returned immediately; the new process executes concurrently with the current process. The standard input and outputs of the new process are connected to the descriptors stdin, stdout and stderr. Passing e.g. Unix.stdout for stdout prevents the redirection and causes the new process to have the same standard output as the current process. The executable file prog is searched in the path. The new process has the same environment as the current process.
val create_process_env :
+ prog:string ->
+ args:string array ->
+ env:string array ->
+ stdin:file_descr ->
+ stdout:file_descr ->
+ stderr:file_descr ->
+ intcreate_process_env ~prog ~args ~env ~stdin ~stdout ~stderr works as create_process, except that the extra argument env specifies the environment passed to the program.
val open_process_in : string -> in_channelHigh-level pipe and process management. This function runs the given command in parallel with the program. The standard output of the command is redirected to a pipe, which can be read via the returned input channel. The command is interpreted by the shell /bin/sh (or cmd.exe on Windows), cf. system. The Filename.quote_command function can be used to quote the command and its arguments as appropriate for the shell being used. If the command does not need to be run through the shell, open_process_args_in can be used as a more robust and more efficient alternative to open_process_in.
val open_process_out : string -> out_channelSame as open_process_in, but redirect the standard input of the command to a pipe. Data written to the returned output channel is sent to the standard input of the command. Warning: writes on output channels are buffered, hence be careful to call Stdlib.flush at the right times to ensure correct synchronization. If the command does not need to be run through the shell, open_process_args_out can be used instead of open_process_out.
val open_process : string -> in_channel * out_channelSame as open_process_out, but redirects both the standard input and standard output of the command to pipes connected to the two returned channels. The input channel is connected to the output of the command, and the output channel to the input of the command. If the command does not need to be run through the shell, open_process_args can be used instead of open_process.
val open_process_full :
+ string ->
+ env:string array ->
+ in_channel * out_channel * in_channelSimilar to open_process, but the second argument specifies the environment passed to the command. The result is a triple of channels connected respectively to the standard output, standard input, and standard error of the command. If the command does not need to be run through the shell, open_process_args_full can be used instead of open_process_full.
val open_process_args_in : string -> string array -> in_channelopen_process_args_in prog args runs the program prog with arguments args. The new process executes concurrently with the current process. The standard output of the new process is redirected to a pipe, which can be read via the returned input channel.
The executable file prog is searched in the path. This behaviour changed in 4.12; previously prog was looked up only in the current directory.
The new process has the same environment as the current process.
val open_process_args_out : string -> string array -> out_channelSame as open_process_args_in, but redirect the standard input of the new process to a pipe. Data written to the returned output channel is sent to the standard input of the program. Warning: writes on output channels are buffered, hence be careful to call Stdlib.flush at the right times to ensure correct synchronization.
val open_process_args : string -> string array -> in_channel * out_channelSame as open_process_args_out, but redirects both the standard input and standard output of the new process to pipes connected to the two returned channels. The input channel is connected to the output of the program, and the output channel to the input of the program.
val open_process_args_full :
+ string ->
+ string array ->
+ string array ->
+ in_channel * out_channel * in_channelSimilar to open_process_args, but the third argument specifies the environment passed to the new process. The result is a triple of channels connected respectively to the standard output, standard input, and standard error of the program.
val process_in_pid : in_channel -> intReturn the pid of a process opened via open_process_in or open_process_args_in.
val process_out_pid : out_channel -> intReturn the pid of a process opened via open_process_out or open_process_args_out.
val process_pid : (in_channel * out_channel) -> intReturn the pid of a process opened via open_process or open_process_args.
val process_full_pid : (in_channel * out_channel * in_channel) -> intReturn the pid of a process opened via open_process_full or open_process_args_full.
val close_process_in : in_channel -> process_statusClose channels opened by open_process_in, wait for the associated command to terminate, and return its termination status.
val close_process_out : out_channel -> process_statusClose channels opened by open_process_out, wait for the associated command to terminate, and return its termination status.
val close_process : (in_channel * out_channel) -> process_statusClose channels opened by open_process, wait for the associated command to terminate, and return its termination status.
val close_process_full :
+ (in_channel * out_channel * in_channel) ->
+ process_statusClose channels opened by open_process_full, wait for the associated command to terminate, and return its termination status.
symlink ?to_dir ~src ~dst creates the file dst as a symbolic link to the file src. On Windows, ~to_dir indicates if the symbolic link points to a directory or a file; if omitted, symlink examines src using stat and picks appropriately, if src does not exist then false is assumed (for this reason, it is recommended that the ~to_dir parameter be specified in new code). On Unix, ~to_dir is ignored.
Windows symbolic links are available in Windows Vista onwards. There are some important differences between Windows symlinks and their POSIX counterparts.
Windows symbolic links come in two flavours: directory and regular, which designate whether the symbolic link points to a directory or a file. The type must be correct - a directory symlink which actually points to a file cannot be selected with chdir and a file symlink which actually points to a directory cannot be read or written (note that Cygwin's emulation layer ignores this distinction).
When symbolic links are created to existing targets, this distinction doesn't matter and symlink will automatically create the correct kind of symbolic link. The distinction matters when a symbolic link is created to a non-existent target.
The other caveat is that by default symbolic links are a privileged operation. Administrators will always need to be running elevated (or with UAC disabled) and by default normal user accounts need to be granted the SeCreateSymbolicLinkPrivilege via Local Security Policy (secpol.msc) or via Active Directory.
has_symlink can be used to check that a process is able to create symbolic links.
Returns true if the user is able to create symbolic links. On Windows, this indicates that the user not only has the SeCreateSymbolicLinkPrivilege but is also running elevated, if necessary. On other platforms, this is simply indicates that the symlink system call is available.
val select :
+ read:file_descr list ->
+ write:file_descr list ->
+ except:file_descr list ->
+ timeout:float ->
+ file_descr list * file_descr list * file_descr listWait until some input/output operations become possible on some channels. The three list arguments are, respectively, a set of descriptors to check for reading (first argument), for writing (second argument), or for exceptional conditions (third argument). The fourth argument is the maximal timeout, in seconds; a negative fourth argument means no timeout (unbounded wait). The result is composed of three sets of descriptors: those ready for reading (first component), ready for writing (second component), and over which an exceptional condition is pending (third component).
type lock_command = Unix.lock_command = | F_ULOCKUnlock a region
*)| F_LOCKLock a region for writing, and block if already locked
*)| F_TLOCKLock a region for writing, or fail if already locked
*)| F_TESTTest a region for other process locks
*)| F_RLOCKLock a region for reading, and block if already locked
*)| F_TRLOCKLock a region for reading, or fail if already locked
*)Commands for lockf.
val lockf : file_descr -> mode:lock_command -> len:int -> unitlockf fd ~mode ~len puts a lock on a region of the file opened as fd. The region starts at the current read/write position for fd (as set by lseek), and extends len bytes forward if len is positive, len bytes backwards if len is negative, or to the end of the file if len is zero. A write lock prevents any other process from acquiring a read or write lock on the region. A read lock prevents any other process from acquiring a write lock on the region, but lets other processes acquire read locks on it.
The F_LOCK and F_TLOCK commands attempts to put a write lock on the specified region. The F_RLOCK and F_TRLOCK commands attempts to put a read lock on the specified region. If one or several locks put by another process prevent the current process from acquiring the lock, F_LOCK and F_RLOCK block until these locks are removed, while F_TLOCK and F_TRLOCK fail immediately with an exception. The F_ULOCK removes whatever locks the current process has on the specified region. Finally, the F_TEST command tests whether a write lock can be acquired on the specified region, without actually putting a lock. It returns immediately if successful, or fails otherwise.
What happens when a process tries to lock a region of a file that is already locked by the same process depends on the OS. On POSIX-compliant systems, the second lock operation succeeds and may "promote" the older lock from read lock to write lock. On Windows, the second lock operation will block or fail.
Note: installation of signal handlers is performed via the functions Sys.signal and Sys.set_signal.
kill ~pid ~signal sends signal number signal to the process with id pid.
On Windows: only the Sys.sigkill signal is emulated.
val sigprocmask : mode:sigprocmask_command -> int list -> int listsigprocmask ~mode sigs changes the set of blocked signals. If mode is SIG_SETMASK, blocked signals are set to those in the list sigs. If mode is SIG_BLOCK, the signals in sigs are added to the set of blocked signals. If mode is SIG_UNBLOCK, the signals in sigs are removed from the set of blocked signals. sigprocmask returns the set of previously blocked signals.
When the systhreads version of the Thread module is loaded, this function redirects to Thread.sigmask. I.e., sigprocmask only changes the mask of the current thread.
sigsuspend sigs atomically sets the blocked signals to sigs and waits for a non-ignored, non-blocked signal to be delivered. On return, the blocked signals are reset to their initial value.
type process_times = Unix.process_times = {tms_utime : float;User time for the process
*)tms_stime : float;System time for the process
*)tms_cutime : float;User time for the children processes
*)tms_cstime : float;System time for the children processes
*)}The execution times (CPU times) of a process.
type tm = Unix.tm = {tm_sec : int;Seconds 0..60
*)tm_min : int;Minutes 0..59
*)tm_hour : int;Hours 0..23
*)tm_mday : int;Day of month 1..31
*)tm_mon : int;Month of year 0..11
*)tm_year : int;Year - 1900
*)tm_wday : int;Day of week (Sunday is 0)
*)tm_yday : int;Day of year 0..365
*)tm_isdst : bool;Daylight time savings in effect
*)}The type representing wallclock time and calendar date.
Same as time, but with resolution better than 1 second.
val gmtime : float -> tmval localtime : float -> tmConvert a date and time, specified by the tm argument, into a time in seconds, as returned by time. The tm_isdst, tm_wday and tm_yday fields of tm are ignored. Also return a normalized copy of the given tm record, with the tm_wday, tm_yday, and tm_isdst fields recomputed from the other fields, and the other fields normalized (so that, e.g., 40 October is changed into 9 November). The tm argument is interpreted in the local time zone.
Stop execution for the given number of seconds. Like sleep, but fractions of seconds are supported.
val times : unit -> process_timesReturn the execution times of the process.
On Windows: partially implemented, will not report timings for child processes.
Set the last access time (second arg) and last modification time (third arg) for a file. Times are expressed in seconds from 00:00:00 GMT, Jan. 1, 1970. If both times are 0.0, the access and last modification times are both set to the current time.
type interval_timer = Unix.interval_timer = | ITIMER_REALdecrements in real time, and sends the signal SIGALRM when expired.
| ITIMER_VIRTUALdecrements in process virtual time, and sends SIGVTALRM when expired.
| ITIMER_PROF(for profiling) decrements both when the process is running and when the system is running on behalf of the process; it sends SIGPROF when expired.
The three kinds of interval timers.
The type describing the status of an interval timer
val getitimer : interval_timer -> interval_timer_statusReturn the current status of the given interval timer.
val setitimer :
+ interval_timer ->
+ interval_timer_status ->
+ interval_timer_statussetitimer t s sets the interval timer t and returns its previous status. The s argument is interpreted as follows: s.it_value, if nonzero, is the time to the next timer expiration; s.it_interval, if nonzero, specifies a value to be used in reloading it_value when the timer expires. Setting s.it_value to zero disables the timer. Setting s.it_interval to zero causes the timer to be disabled after its next expiration.
Return the user id of the user executing the process.
On Windows: always returns 1.
Return the effective user id under which the process runs.
On Windows: always returns 1.
Return the group id of the user executing the process.
On Windows: always returns 1.
Return the effective group id under which the process runs.
On Windows: always returns 1.
Return the list of groups to which the user executing the process belongs.
On Windows: always returns [|1|].
setgroups groups sets the supplementary group IDs for the calling process. Appropriate privileges are required.
initgroups user group initializes the group access list by reading the group database /etc/group and using all groups of which user is a member. The additional group group is also added to the list.
type passwd_entry = Unix.passwd_entry = {pw_name : string;pw_passwd : string;pw_uid : int;pw_gid : int;pw_gecos : string;pw_dir : string;pw_shell : string;}Structure of entries in the passwd database.
Structure of entries in the groups database.
val getpwnam : string -> passwd_entryFind an entry in passwd with the given name.
val getgrnam : string -> group_entryFind an entry in group with the given name.
val getpwuid : int -> passwd_entryFind an entry in passwd with the given user id.
val getgrgid : int -> group_entryFind an entry in group with the given group id.
type inet_addr = Unix.inet_addrThe abstract type of Internet addresses.
val inet_addr_of_string : string -> inet_addrConversion from the printable representation of an Internet address to its internal representation. The argument string consists of 4 numbers separated by periods (XXX.YYY.ZZZ.TTT) for IPv4 addresses, and up to 8 numbers separated by colons for IPv6 addresses.
val string_of_inet_addr : inet_addr -> stringReturn the printable representation of the given Internet address. See inet_addr_of_string for a description of the printable representation.
val inet_addr_any : inet_addrA special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
val inet_addr_loopback : inet_addrA special IPv4 address representing the host machine (127.0.0.1).
val inet6_addr_any : inet_addrA special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
val inet6_addr_loopback : inet_addrA special IPv6 address representing the host machine (::1).
val is_inet6_addr : inet_addr -> boolWhether the given inet_addr is an IPv6 address.
type socket_domain = Unix.socket_domain = The type of socket domains. Not all platforms support IPv6 sockets (type PF_INET6).
On Windows: PF_UNIX supported since 4.14.0 on Windows 10 1803 and later.
type socket_type = Unix.socket_type = The type of socket kinds, specifying the semantics of communications. SOCK_SEQPACKET is included for completeness, but is rarely supported by the OS, and needs system calls that are not available in this library.
The type of socket addresses. ADDR_UNIX name is a socket address in the Unix domain; name is a file name in the file system. ADDR_INET(addr,port) is a socket address in the Internet domain; addr is the Internet address of the machine, and port is the port number.
val socket :
+ ?cloexec:bool ->
+ domain:socket_domain ->
+ kind:socket_type ->
+ protocol:int ->
+ file_descrCreate a new socket in the given domain, and with the given kind. The third argument is the protocol type; 0 selects the default protocol for that kind of sockets. See set_close_on_exec for documentation on the cloexec optional argument.
val domain_of_sockaddr : sockaddr -> socket_domainReturn the socket domain adequate for the given socket address.
val socketpair :
+ ?cloexec:bool ->
+ domain:socket_domain ->
+ kind:socket_type ->
+ protocol:int ->
+ file_descr * file_descrCreate a pair of unnamed sockets, connected together. See set_close_on_exec for documentation on the cloexec optional argument.
val accept : ?cloexec:bool -> file_descr -> file_descr * sockaddrAccept connections on the given socket. The returned descriptor is a socket connected to the client; the returned address is the address of the connecting client. See set_close_on_exec for documentation on the cloexec optional argument.
val bind : file_descr -> addr:sockaddr -> unitBind a socket to an address.
val connect : file_descr -> addr:sockaddr -> unitConnect a socket to an address.
val listen : file_descr -> max:int -> unitSet up a socket for receiving connection requests. The integer argument is the maximal number of pending requests.
type shutdown_command = Unix.shutdown_command = The type of commands for shutdown.
val shutdown : file_descr -> mode:shutdown_command -> unitShutdown a socket connection. SHUTDOWN_SEND as second argument causes reads on the other end of the connection to return an end-of-file condition. SHUTDOWN_RECEIVE causes writes on the other end of the connection to return a closed pipe condition (SIGPIPE signal).
val getsockname : file_descr -> sockaddrReturn the address of the given socket.
val getpeername : file_descr -> sockaddrReturn the address of the host connected to the given socket.
val recv :
+ file_descr ->
+ buf:bytes ->
+ pos:int ->
+ len:int ->
+ mode:msg_flag list ->
+ intReceive data from a connected socket.
val recvfrom :
+ file_descr ->
+ buf:bytes ->
+ pos:int ->
+ len:int ->
+ mode:msg_flag list ->
+ int * sockaddrReceive data from an unconnected socket.
val send :
+ file_descr ->
+ buf:bytes ->
+ pos:int ->
+ len:int ->
+ mode:msg_flag list ->
+ intSend data over a connected socket.
val send_substring :
+ file_descr ->
+ buf:string ->
+ pos:int ->
+ len:int ->
+ mode:msg_flag list ->
+ intSame as send, but take the data from a string instead of a byte sequence.
val sendto :
+ file_descr ->
+ buf:bytes ->
+ pos:int ->
+ len:int ->
+ mode:msg_flag list ->
+ addr:sockaddr ->
+ intSend data over an unconnected socket.
val sendto_substring :
+ file_descr ->
+ buf:string ->
+ pos:int ->
+ len:int ->
+ mode:msg_flag list ->
+ sockaddr ->
+ intSame as sendto, but take the data from a string instead of a byte sequence.
type socket_bool_option = Unix.socket_bool_option = | SO_DEBUGRecord debugging information
*)| SO_BROADCASTPermit sending of broadcast messages
*)| SO_REUSEADDRAllow reuse of local addresses for bind
*)| SO_KEEPALIVEKeep connection active
*)| SO_DONTROUTEBypass the standard routing algorithms
*)| SO_OOBINLINELeave out-of-band data in line
*)| SO_ACCEPTCONNReport whether socket listening is enabled
*)| TCP_NODELAYControl the Nagle algorithm for TCP sockets
*)| IPV6_ONLYForbid binding an IPv6 socket to an IPv4 address
*)| SO_REUSEPORTAllow reuse of address and port bindings
*)The socket options that can be consulted with getsockopt and modified with setsockopt. These options have a boolean (true/false) value.
type socket_int_option = Unix.socket_int_option = The socket options that can be consulted with getsockopt_int and modified with setsockopt_int. These options have an integer value.
type socket_optint_option = Unix.socket_optint_option = The socket options that can be consulted with getsockopt_optint and modified with setsockopt_optint. These options have a value of type int option, with None meaning ``disabled''.
type socket_float_option = Unix.socket_float_option = The socket options that can be consulted with getsockopt_float and modified with setsockopt_float. These options have a floating-point value representing a time in seconds. The value 0 means infinite timeout.
val getsockopt : file_descr -> socket_bool_option -> boolReturn the current status of a boolean-valued option in the given socket.
val setsockopt : file_descr -> socket_bool_option -> bool -> unitSet or clear a boolean-valued option in the given socket.
val getsockopt_int : file_descr -> socket_int_option -> intSame as getsockopt for an integer-valued socket option.
val setsockopt_int : file_descr -> socket_int_option -> int -> unitSame as setsockopt for an integer-valued socket option.
val getsockopt_optint : file_descr -> socket_optint_option -> int optionSame as getsockopt for a socket option whose value is an int option.
val setsockopt_optint :
+ file_descr ->
+ socket_optint_option ->
+ int option ->
+ unitSame as setsockopt for a socket option whose value is an int option.
val getsockopt_float : file_descr -> socket_float_option -> floatSame as getsockopt for a socket option whose value is a floating-point number.
val setsockopt_float : file_descr -> socket_float_option -> float -> unitSame as setsockopt for a socket option whose value is a floating-point number.
val getsockopt_error : file_descr -> error optionReturn the error condition associated with the given socket, and clear it.
val open_connection : sockaddr -> in_channel * out_channelConnect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call Stdlib.flush on the output channel at the right times to ensure correct synchronization.
The two channels returned by open_connection share a descriptor to a socket. Therefore, when the connection is over, you should call Stdlib.close_out on the output channel, which will also close the underlying socket. Do not call Stdlib.close_in on the input channel; it will be collected by the GC eventually.
val shutdown_connection : in_channel -> unit``Shut down'' a connection established with open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection. This does not close the socket and the channels used by the connection. See Unix.open_connection for how to close them once the connection is over.
val establish_server :
+ (in_channel -> out_channel -> unit) ->
+ addr:sockaddr ->
+ unitEstablish a server on the given address. The function given as first argument is called for each connection with two buffered channels connected to the client. A new process is created for each connection. The function establish_server never returns normally.
The two channels given to the function share a descriptor to a socket. The function does not need to close the channels, since this occurs automatically when the function returns. If the function prefers explicit closing, it should close the output channel using Stdlib.close_out and leave the input channel unclosed, for reasons explained in Unix.in_channel_of_descr.
type host_entry = Unix.host_entry = {h_name : string;h_aliases : string array;h_addrtype : socket_domain;h_addr_list : inet_addr array;}Structure of entries in the hosts database.
Structure of entries in the protocols database.
Structure of entries in the services database.
val gethostbyname : string -> host_entryFind an entry in hosts with the given name.
val gethostbyaddr : inet_addr -> host_entryFind an entry in hosts with the given address.
val getprotobyname : string -> protocol_entryFind an entry in protocols with the given name.
val getprotobynumber : int -> protocol_entryFind an entry in protocols with the given protocol number.
val getservbyname : string -> protocol:string -> service_entryFind an entry in services with the given name.
val getservbyport : int -> protocol:string -> service_entryFind an entry in services with the given service number.
type addr_info = Unix.addr_info = {ai_family : socket_domain;Socket domain
*)ai_socktype : socket_type;Socket type
*)ai_protocol : int;Socket protocol number
*)ai_addr : sockaddr;Address
*)ai_canonname : string;Canonical host name
*)}Address information returned by getaddrinfo.
type getaddrinfo_option = Unix.getaddrinfo_option = | AI_FAMILY of socket_domainImpose the given socket domain
*)| AI_SOCKTYPE of socket_typeImpose the given socket type
*)| AI_PROTOCOL of intImpose the given protocol
*)| AI_NUMERICHOSTDo not call name resolver, expect numeric IP address
*)| AI_CANONNAMEFill the ai_canonname field of the result
| AI_PASSIVEOptions to getaddrinfo.
val getaddrinfo : string -> string -> getaddrinfo_option list -> addr_info listgetaddrinfo host service opts returns a list of addr_info records describing socket parameters and addresses suitable for communicating with the given host and service. The empty list is returned if the host or service names are unknown, or the constraints expressed in opts cannot be satisfied.
host is either a host name or the string representation of an IP address. host can be given as the empty string; in this case, the ``any'' address or the ``loopback'' address are used, depending whether opts contains AI_PASSIVE. service is either a service name or the string representation of a port number. service can be given as the empty string; in this case, the port field of the returned addresses is set to 0. opts is a possibly empty list of options that allows the caller to force a particular socket domain (e.g. IPv6 only or IPv4 only) or a particular socket type (e.g. TCP only or UDP only).
type name_info = Unix.name_info = {ni_hostname : string;Name or IP address of host
*)ni_service : string;Name of service or port number
*)}Host and service information returned by getnameinfo.
type getnameinfo_option = Unix.getnameinfo_option = Options to getnameinfo.
val getnameinfo : sockaddr -> getnameinfo_option list -> name_infogetnameinfo addr opts returns the host name and service name corresponding to the socket address addr. opts is a possibly empty list of options that governs how these names are obtained.
The following functions implement the POSIX standard terminal interface. They provide control over asynchronous communication ports and pseudo-terminals. Refer to the termios man page for a complete description.
type terminal_io = Unix.terminal_io = {mutable c_ignbrk : bool;Ignore the break condition.
*)mutable c_brkint : bool;Signal interrupt on break condition.
*)mutable c_ignpar : bool;Ignore characters with parity errors.
*)mutable c_parmrk : bool;Mark parity errors.
*)mutable c_inpck : bool;Enable parity check on input.
*)mutable c_istrip : bool;Strip 8th bit on input characters.
*)mutable c_inlcr : bool;Map NL to CR on input.
*)mutable c_igncr : bool;Ignore CR on input.
*)mutable c_icrnl : bool;Map CR to NL on input.
*)mutable c_ixon : bool;Recognize XON/XOFF characters on input.
*)mutable c_ixoff : bool;Emit XON/XOFF chars to control input flow.
*)mutable c_opost : bool;Enable output processing.
*)mutable c_obaud : int;Output baud rate (0 means close connection).
*)mutable c_ibaud : int;Input baud rate.
*)mutable c_csize : int;Number of bits per character (5-8).
*)mutable c_cstopb : int;Number of stop bits (1-2).
*)mutable c_cread : bool;Reception is enabled.
*)mutable c_parenb : bool;Enable parity generation and detection.
*)mutable c_parodd : bool;Specify odd parity instead of even.
*)mutable c_hupcl : bool;Hang up on last close.
*)mutable c_clocal : bool;Ignore modem status lines.
*)mutable c_isig : bool;Generate signal on INTR, QUIT, SUSP.
*)mutable c_icanon : bool;Enable canonical processing (line buffering and editing)
*)mutable c_noflsh : bool;Disable flush after INTR, QUIT, SUSP.
*)mutable c_echo : bool;Echo input characters.
*)mutable c_echoe : bool;Echo ERASE (to erase previous character).
*)mutable c_echok : bool;Echo KILL (to erase the current line).
*)mutable c_echonl : bool;Echo NL even if c_echo is not set.
*)mutable c_vintr : char;Interrupt character (usually ctrl-C).
*)mutable c_vquit : char;Quit character (usually ctrl-\).
*)mutable c_verase : char;Erase character (usually DEL or ctrl-H).
*)mutable c_vkill : char;Kill line character (usually ctrl-U).
*)mutable c_veof : char;End-of-file character (usually ctrl-D).
*)mutable c_veol : char;Alternate end-of-line char. (usually none).
*)mutable c_vmin : int;Minimum number of characters to read before the read request is satisfied.
*)mutable c_vtime : int;Maximum read wait (in 0.1s units).
*)mutable c_vstart : char;Start character (usually ctrl-Q).
*)mutable c_vstop : char;Stop character (usually ctrl-S).
*)}val tcgetattr : file_descr -> terminal_ioReturn the status of the terminal referred to by the given file descriptor.
val tcsetattr : file_descr -> mode:setattr_when -> terminal_io -> unitSet the status of the terminal referred to by the given file descriptor. The second argument indicates when the status change takes place: immediately (TCSANOW), when all pending output has been transmitted (TCSADRAIN), or after flushing all input that has been received but not read (TCSAFLUSH). TCSADRAIN is recommended when changing the output parameters; TCSAFLUSH, when changing the input parameters.
val tcsendbreak : file_descr -> duration:int -> unitSend a break condition on the given file descriptor. The second argument is the duration of the break, in 0.1s units; 0 means standard duration (0.25s).
val tcdrain : file_descr -> unitWaits until all output written on the given file descriptor has been transmitted.
val tcflush : file_descr -> mode:flush_queue -> unitDiscard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: TCIFLUSH flushes data received but not read, TCOFLUSH flushes data written but not transmitted, and TCIOFLUSH flushes both.
val tcflow : file_descr -> mode:flow_action -> unitSuspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: TCOOFF suspends output, TCOON restarts output, TCIOFF transmits a STOP character to suspend input, and TCION transmits a START character to restart input.
Untypeastval lident_of_path : Path.t -> Longident.ttype mapper = {attribute : mapper -> Typedtree.attribute -> Parsetree.attribute;attributes : mapper -> Typedtree.attribute list -> Parsetree.attribute list;binding_op : mapper ->
+ Typedtree.binding_op ->
+ Typedtree.pattern ->
+ Parsetree.binding_op;case : 'k. mapper -> 'k Typedtree.case -> Parsetree.case;class_declaration : mapper ->
+ Typedtree.class_declaration ->
+ Parsetree.class_declaration;class_description : mapper ->
+ Typedtree.class_description ->
+ Parsetree.class_description;class_expr : mapper -> Typedtree.class_expr -> Parsetree.class_expr;class_field : mapper -> Typedtree.class_field -> Parsetree.class_field;class_signature : mapper ->
+ Typedtree.class_signature ->
+ Parsetree.class_signature;class_structure : mapper ->
+ Typedtree.class_structure ->
+ Parsetree.class_structure;class_type : mapper -> Typedtree.class_type -> Parsetree.class_type;class_type_declaration : mapper ->
+ Typedtree.class_type_declaration ->
+ Parsetree.class_type_declaration;class_type_field : mapper ->
+ Typedtree.class_type_field ->
+ Parsetree.class_type_field;constructor_declaration : mapper ->
+ Typedtree.constructor_declaration ->
+ Parsetree.constructor_declaration;expr : mapper -> Typedtree.expression -> Parsetree.expression;extension_constructor : mapper ->
+ Typedtree.extension_constructor ->
+ Parsetree.extension_constructor;include_declaration : mapper ->
+ Typedtree.include_declaration ->
+ Parsetree.include_declaration;include_description : mapper ->
+ Typedtree.include_description ->
+ Parsetree.include_description;label_declaration : mapper ->
+ Typedtree.label_declaration ->
+ Parsetree.label_declaration;location : mapper -> Location.t -> Location.t;module_binding : mapper ->
+ Typedtree.module_binding ->
+ Parsetree.module_binding;module_declaration : mapper ->
+ Typedtree.module_declaration ->
+ Parsetree.module_declaration;module_substitution : mapper ->
+ Typedtree.module_substitution ->
+ Parsetree.module_substitution;module_expr : mapper -> Typedtree.module_expr -> Parsetree.module_expr;module_type : mapper -> Typedtree.module_type -> Parsetree.module_type;module_type_declaration : mapper ->
+ Typedtree.module_type_declaration ->
+ Parsetree.module_type_declaration;package_type : mapper -> Typedtree.package_type -> Parsetree.package_type;open_declaration : mapper ->
+ Typedtree.open_declaration ->
+ Parsetree.open_declaration;open_description : mapper ->
+ Typedtree.open_description ->
+ Parsetree.open_description;pat : 'k. mapper -> 'k Typedtree.general_pattern -> Parsetree.pattern;row_field : mapper -> Typedtree.row_field -> Parsetree.row_field;object_field : mapper -> Typedtree.object_field -> Parsetree.object_field;signature : mapper -> Typedtree.signature -> Parsetree.signature;signature_item : mapper ->
+ Typedtree.signature_item ->
+ Parsetree.signature_item;structure : mapper -> Typedtree.structure -> Parsetree.structure;structure_item : mapper ->
+ Typedtree.structure_item ->
+ Parsetree.structure_item;typ : mapper -> Typedtree.core_type -> Parsetree.core_type;type_declaration : mapper ->
+ Typedtree.type_declaration ->
+ Parsetree.type_declaration;type_extension : mapper ->
+ Typedtree.type_extension ->
+ Parsetree.type_extension;type_exception : mapper ->
+ Typedtree.type_exception ->
+ Parsetree.type_exception;type_kind : mapper -> Typedtree.type_kind -> Parsetree.type_kind;value_binding : mapper -> Typedtree.value_binding -> Parsetree.value_binding;value_description : mapper ->
+ Typedtree.value_description ->
+ Parsetree.value_description;with_constraint : mapper ->
+ (Path.t * Longident.t Location.loc * Typedtree.with_constraint) ->
+ Parsetree.with_constraint;}val default_mapper : mapperval untype_structure :
+ ?mapper:mapper ->
+ Typedtree.structure ->
+ Parsetree.structureval untype_signature :
+ ?mapper:mapper ->
+ Typedtree.signature ->
+ Parsetree.signatureval untype_expression :
+ ?mapper:mapper ->
+ Typedtree.expression ->
+ Parsetree.expressionval untype_pattern :
+ ?mapper:mapper ->
+ _ Typedtree.general_pattern ->
+ Parsetree.patternval constant : Asttypes.constant -> Parsetree.constantVar_within_closure.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitVar_within_closure.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringVar_within_closure.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitVar_within_closure.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tVar_within_closureAn identifier, unique across the whole program, that identifies a particular variable within a particular closure. Only Project_var, and not Var, nodes are tagged with these identifiers.
include module type of Closure_elementinclude Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval wrap : Variable.t -> tval unwrap : t -> Variable.tval wrap_map : 'a Variable.Map.t -> 'a Map.tval unwrap_set : Set.t -> Variable.Set.tval in_compilation_unit : t -> Compilation_unit.t -> boolval get_compilation_unit : t -> Compilation_unit.tval unique_name : t -> stringval output_full : out_channel -> t -> unitVariable.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitPair.Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).ttype key = T.tThe type of the map keys.
type 'a t = 'a Stdlib.Map.Make(T).tThe type of maps from type key to type 'a.
val empty : 'a tThe empty map.
val is_empty : 'a t -> boolTest whether a map is empty or not.
mem x m returns true if m contains a binding for x, and false otherwise.
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.
update key f m returns a map containing the same bindings as m, except for the binding of key. Depending on the value of y where y is f (find_opt key m), the binding of key is added, removed or updated. If y is None, the binding is removed if it exists; otherwise, if y is Some z then key is associated to z in the resulting map. If key was already bound in m to a value that is physically equal to z, m is returned unchanged (the result of the function is then physically equal to m).
singleton x y returns the one-element map that contains a binding y for x.
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).
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 x None None = None.
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, where
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
iter f m applies f to all bindings in map m. f receives the key as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
for_all f m checks if all the bindings of the map satisfy the predicate f.
exists f m checks if at least one binding of the map satisfies the predicate f.
filter f m returns the map with all the bindings in m that satisfy predicate p. If every binding in m satisfies f, m is returned unchanged (the result of the function is then physically equal to m)
filter_map f m applies the function f to every binding of m, and builds a map from the results. For each binding (k, v) in the input map:
f k v is None then k is not in the result,f k v is Some v' then the binding (k, v') is in the output map.For example, the following function on maps whose values are lists
filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ mdrops all bindings of m whose value is an empty list, and pops the first element of each value that is non-empty.
partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.
val cardinal : 'a t -> intReturn the number of bindings of a map.
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 Stdlib.Map.Make.
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.
Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
Same as min_binding, but returns the binding with the largest key in the given map.
Same as min_binding_opt, but returns the binding with the largest key in the given map.
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.
Return one binding of the given map, or None if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.
For example, find_first (fun k -> Ord.compare k x >= 0) m will return the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k >= x), or raise Not_found if x is greater than any element of m.
find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.
find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.
find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in ascending order of keys
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.tIterate on the whole map, in descending order of keys
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.tto_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a tAdd the given bindings to the map, in order.
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a tBuild a map from the given bindings
val disjoint_union :
+ ?eq:('a -> 'a -> bool) ->
+ ?print:(Stdlib.Format.formatter -> 'a -> unit) ->
+ 'a t ->
+ 'a t ->
+ 'a tdisjoint_union m1 m2 contains all bindings from m1 and m2. If some binding is present in both and the associated value is not equal, a Fatal_error is raised
union_right m1 m2 contains all bindings from m1 and m2. If some binding is present in both, the one from m2 is taken
val keys : 'a t -> Stdlib.Set.Make(T).tval data : 'a t -> 'a listval of_set : (key -> 'a) -> Stdlib.Set.Make(T).t -> 'a tval transpose_keys_and_data_set : key t -> Stdlib.Set.Make(T).t tval print :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitPair.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringPair.Ttype t = pairinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitPair.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tVariable.Pairmodule T : Identifiable.Thing with type t = pairinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := TVariable.Setinclude Set.S with type elt = T.t and type t = Set.Make(T).ttype elt = T.tThe type of the set elements.
type t = Stdlib.Set.Make(T).tThe type of sets.
val empty : tThe empty set.
val is_empty : t -> boolTest whether a set is empty or not.
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged (the result of the function is then physically equal to s).
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged (the result of the function is then physically equal to s).
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
iter f s applies f in turn to all elements of s. The elements of s are presented to f in increasing order with respect to the ordering over the type of the elements.
fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
for_all f s checks if all elements of the set satisfy the predicate f.
exists f s checks if at least one element of the set satisfies the predicate f.
filter f s returns the set of all elements in s that satisfy predicate f. If f satisfies every element in s, s is returned unchanged (the result of the function is then physically equal to s).
filter_map f s returns the set of all v such that f x = Some v for some element x of s.
For example,
filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) sis the set of halves of the even elements of s.
If no element of s is changed or dropped by f (if f x = Some x for each element x), then s is returned unchanged: the result of the function is then physically equal to s.
partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.
val cardinal : t -> intReturn the number of elements of a set.
Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering Ord.compare, where Ord is the argument given to Stdlib.Set.Make.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.
Same as min_elt_opt, but returns the largest element of the given set.
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
Return one element of the given set, or None if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s.
find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.
find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.
find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.
val to_seq_from : elt -> t -> elt Stdlib.Seq.tto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
val to_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in ascending order
val to_rev_seq : t -> elt Stdlib.Seq.tIterate on the whole set, in descending order
val add_seq : elt Stdlib.Seq.t -> t -> tAdd the given elements to the set, in order.
val of_seq : elt Stdlib.Seq.t -> tBuild a set from the given bindings
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringVariable.Ttype t = tinclude Hashtbl.HashedType with type t := tval hash : t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> t -> unitval print : Stdlib.Format.formatter -> t -> unitVariable.Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).ttype key = T.ttype 'a t = 'a Stdlib.Hashtbl.Make(T).tval create : int -> 'a tval clear : 'a t -> unitval reset : 'a t -> unitval length : 'a t -> intval stats : 'a t -> Stdlib.Hashtbl.statisticsval to_seq : 'a t -> (key * 'a) Stdlib.Seq.tval to_seq_keys : _ t -> key Stdlib.Seq.tval to_seq_values : 'a t -> 'a Stdlib.Seq.tval add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unitval of_seq : (key * 'a) Stdlib.Seq.t -> 'a tval to_map : 'a t -> 'a Stdlib.Map.Make(T).tval of_map : 'a Stdlib.Map.Make(T).t -> 'a tVariableVariable.t is the equivalent of a non-persistent Ident.t in the Flambda tree. It wraps an Ident.t together with its source compilation_unit. As such, it is unique within a whole program, not just one compilation unit.
Introducing a new type helps in tracing the source of identifiers when debugging the inliner. It also avoids Ident renaming when importing cmx files.
include Identifiable.Smodule T : Identifiable.Thing with type t = tinclude Identifiable.Thing with type t := T.tinclude Hashtbl.HashedType with type t := T.tval hash : T.t -> intA hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include
(=), hash) for comparing objects by structure (provided objects do not contain floats)(fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly(==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).include Map.OrderedType with type t := T.tA total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.
val output : out_channel -> T.t -> unitval print : Stdlib.Format.formatter -> T.t -> unitmodule Set : Identifiable.Set with module T := Tmodule Map : Identifiable.Map with module T := Tmodule Tbl : Identifiable.Tbl with module T := Tval create :
+ ?current_compilation_unit:Compilation_unit.t ->
+ Internal_variable_names.t ->
+ tval rename : ?current_compilation_unit:Compilation_unit.t -> t -> tval in_compilation_unit : t -> Compilation_unit.t -> boolval name : t -> stringval unique_name : t -> stringval get_compilation_unit : t -> Compilation_unit.tval print_list : Stdlib.Format.formatter -> t list -> unitval print_opt : Stdlib.Format.formatter -> t option -> unitval debug_when_stamp_matches : t -> stamp:int -> f:(unit -> unit) -> unitIf the given variable has the given stamp, call the user-supplied function. For debugging purposes only.
module Pair : Identifiable.S with type t := pairval output_full : out_channel -> t -> unitUnlike output, output_full includes the compilation unit.
WarningsWarning definitions
Warning: this module is unstable and part of compiler-libs.
type t = | Comment_start| Comment_not_end| Fragile_match of string| Ignored_partial_application| Labels_omitted of string list| Method_override of string list| Partial_match of string| Missing_record_field_pattern of string| Non_unit_statement| Redundant_case| Redundant_subpat| Instance_variable_override of string list| Illegal_backslash| Implicit_public_methods of string list| Unerasable_optional_argument| Undeclared_virtual_method of string| Not_principal of string| Non_principal_labels of string| Ignored_extra_argument| Nonreturning_statement| Preprocessor of string| Useless_record_with| Bad_module_name of string| All_clauses_guarded| Unused_var of string| Unused_var_strict of string| Wildcard_arg_to_constant_constr| Eol_in_string| Duplicate_definitions of string * string * string * string| Module_linked_twice of string * string * string| Unused_value_declaration of string| Unused_open of string| Unused_type_declaration of string| Unused_for_index of string| Unused_ancestor of string| Unused_constructor of string * constructor_usage_warning| Unused_extension of string * bool * constructor_usage_warning| Unused_rec_flag| Name_out_of_scope of string * string list * bool| Ambiguous_name of string list * string list * bool * string| Disambiguated_name of string| Nonoptional_label of string| Open_shadow_identifier of string * string| Open_shadow_label_constructor of string * string| Bad_env_variable of string * string| Attribute_payload of string * string| Eliminated_optional_arguments of string list| No_cmi_file of string * string option| Unexpected_docstring of bool| Wrong_tailcall_expectation of bool| Fragile_literal_pattern| Misplaced_attribute of string| Duplicated_attribute of string| Inlining_impossible of string| Unreachable_case| Ambiguous_var_in_pattern_guard of string list| No_cmx_file of string| Flambda_assignment_to_non_mutable_value| Unused_module of string| Unboxable_type_in_prim_decl of string| Constraint_on_gadt| Erroneous_printed_signature of string| Unsafe_array_syntax_without_parsing| Redefining_unit of string| Unused_open_bang of string| Unused_functor_parameter of string| Match_on_mutable_state_prevent_uncurry| Unused_field of string * field_usage_warning| Missing_mli| Unused_tmc_attribute| Tmc_breaks_tailcallval parse_options : bool -> string -> alert optionDisable/enable alerts based on the parameter to the -alert command-line option. Raises Arg.Bad if the string is not a valid specification.
val is_active : t -> boolval is_error : t -> booltype reporting_information = {id : string;message : string;is_error : bool;sub_locs : (loc * string) list;}val report : t -> [ `Active of reporting_information | `Inactive ]val report_alert : alert -> [ `Active of reporting_information | `Inactive ]val backup : unit -> stateval restore : state -> unitval with_state : state -> (unit -> 'a) -> 'aval mk_lazy : (unit -> 'a) -> 'a Stdlib.Lazy.tLike Lazy.of_fun, but the function is applied with the warning/alert settings at the time mk_lazy is called.
val descriptions : description listX86_astStructured representation of Intel assembly language (32 and 64 bit).
type addr = {arch : arch;typ : data_type;idx : reg64;scale : int;base : reg64 option;sym : string option;displ : int;}Addressing modes: displ + sym + base + idx * scale (if scale = 0, idx is ignored and base must be None)
type arg = | Imm of int64Operand is an immediate constant integer
*)| Sym of stringAddress of a symbol (absolute address except for call/jmp target where it is interpreted as a relative displacement
*)| Reg8L of reg64| Reg8H of reg8h| Reg16 of reg64| Reg32 of reg64| Reg64 of reg64| Regf of registerf| Mem of addr| Mem64_RIP of data_type * string * inttype instruction = | ADD of arg * arg| ADDSD of arg * arg| AND of arg * arg| ANDPD of arg * arg| BSWAP of arg| CALL of arg| CDQ| CMOV of condition * arg * arg| CMP of arg * arg| COMISD of arg * arg| CQO| CVTSD2SI of arg * arg| CVTSD2SS of arg * arg| CVTSI2SD of arg * arg| CVTSS2SD of arg * arg| CVTTSD2SI of arg * arg| DEC of arg| DIVSD of arg * arg| FABS| FADD of arg| FADDP of arg * arg| FCHS| FCOMP of arg| FCOMPP| FCOS| FDIV of arg| FDIVP of arg * arg| FDIVR of arg| FDIVRP of arg * arg| FILD of arg| FISTP of arg| FLD of arg| FLD1| FLDCW of arg| FLDLG2| FLDLN2| FLDZ| FMUL of arg| FMULP of arg * arg| FNSTCW of arg| FNSTSW of arg| FPATAN| FPTAN| FSIN| FSQRT| FSTP of arg| FSUB of arg| FSUBP of arg * arg| FSUBR of arg| FSUBRP of arg * arg| FXCH of arg| FYL2X| HLT| IDIV of arg| IMUL of arg * arg option| INC of arg| J of condition * arg| JMP of arg| LEA of arg * arg| LEAVE| MOV of arg * arg| MOVAPD of arg * arg| MOVLPD of arg * arg| MOVSD of arg * arg| MOVSS of arg * arg| MOVSX of arg * arg| MOVSXD of arg * arg| MOVZX of arg * arg| MULSD of arg * arg| NEG of arg| NOP| OR of arg * arg| POP of arg| PUSH of arg| RET| ROUNDSD of rounding * arg * arg| SAL of arg * arg| SAR of arg * arg| SET of condition * arg| SHR of arg * arg| SQRTSD of arg * arg| SUB of arg * arg| SUBSD of arg * arg| TEST of arg * arg| UCOMISD of arg * arg| XCHG of arg * arg| XOR of arg * arg| XORPD of arg * argtype asm_line = | Ins of instruction| Align of bool * int| Byte of constant| Bytes of string| Comment of string| Global of string| Long of constant| NewLabel of string * data_type| Quad of constant| Section of string list * string option * string list| Space of int| Word of constant| External of string * data_type| Mode386| Model of string| Cfi_adjust_cfa_offset of int| Cfi_endproc| Cfi_startproc| File of int * string| Indirect_symbol of string| Loc of int * int * int| Private_extern of string| Set of string * constant| Size of string * constant| Type of string * stringtype asm_program = asm_line listX86_dsl.DDirectives
val byte : X86_ast.constant -> unitval extrn : string -> X86_ast.data_type -> unitval label : ?typ:X86_ast.data_type -> string -> unitval long : X86_ast.constant -> unitval qword : X86_ast.constant -> unitval setvar : (string * X86_ast.constant) -> unitval size : string -> X86_ast.constant -> unitval word : X86_ast.constant -> unitX86_dsl.Ival add : X86_ast.arg -> X86_ast.arg -> unitval addsd : X86_ast.arg -> X86_ast.arg -> unitval and_ : X86_ast.arg -> X86_ast.arg -> unitval andpd : X86_ast.arg -> X86_ast.arg -> unitval bswap : X86_ast.arg -> unitval call : X86_ast.arg -> unitval cmp : X86_ast.arg -> X86_ast.arg -> unitval comisd : X86_ast.arg -> X86_ast.arg -> unitval cvtsd2ss : X86_ast.arg -> X86_ast.arg -> unitval cvtsi2sd : X86_ast.arg -> X86_ast.arg -> unitval cvtss2sd : X86_ast.arg -> X86_ast.arg -> unitval cvttsd2si : X86_ast.arg -> X86_ast.arg -> unitval dec : X86_ast.arg -> unitval divsd : X86_ast.arg -> X86_ast.arg -> unitval fadd : X86_ast.arg -> unitval faddp : X86_ast.arg -> X86_ast.arg -> unitval fcomp : X86_ast.arg -> unitval fdiv : X86_ast.arg -> unitval fdivp : X86_ast.arg -> X86_ast.arg -> unitval fdivr : X86_ast.arg -> unitval fdivrp : X86_ast.arg -> X86_ast.arg -> unitval fild : X86_ast.arg -> unitval fistp : X86_ast.arg -> unitval fld : X86_ast.arg -> unitval fldcw : X86_ast.arg -> unitval fmul : X86_ast.arg -> unitval fmulp : X86_ast.arg -> X86_ast.arg -> unitval fnstcw : X86_ast.arg -> unitval fnstsw : X86_ast.arg -> unitval fstp : X86_ast.arg -> unitval fsub : X86_ast.arg -> unitval fsubp : X86_ast.arg -> X86_ast.arg -> unitval fsubr : X86_ast.arg -> unitval fsubrp : X86_ast.arg -> X86_ast.arg -> unitval fxch : X86_ast.arg -> unitval idiv : X86_ast.arg -> unitval imul : X86_ast.arg -> X86_ast.arg option -> unitval inc : X86_ast.arg -> unitval j : X86_ast.condition -> X86_ast.arg -> unitval ja : X86_ast.arg -> unitval jae : X86_ast.arg -> unitval jb : X86_ast.arg -> unitval jbe : X86_ast.arg -> unitval je : X86_ast.arg -> unitval jg : X86_ast.arg -> unitval jmp : X86_ast.arg -> unitval jne : X86_ast.arg -> unitval jp : X86_ast.arg -> unitval lea : X86_ast.arg -> X86_ast.arg -> unitval mov : X86_ast.arg -> X86_ast.arg -> unitval movapd : X86_ast.arg -> X86_ast.arg -> unitval movsd : X86_ast.arg -> X86_ast.arg -> unitval movss : X86_ast.arg -> X86_ast.arg -> unitval movsx : X86_ast.arg -> X86_ast.arg -> unitval movsxd : X86_ast.arg -> X86_ast.arg -> unitval movzx : X86_ast.arg -> X86_ast.arg -> unitval mulsd : X86_ast.arg -> X86_ast.arg -> unitval or_ : X86_ast.arg -> X86_ast.arg -> unitval pop : X86_ast.arg -> unitval push : X86_ast.arg -> unitval sal : X86_ast.arg -> X86_ast.arg -> unitval sar : X86_ast.arg -> X86_ast.arg -> unitval set : X86_ast.condition -> X86_ast.arg -> unitval shr : X86_ast.arg -> X86_ast.arg -> unitval sqrtsd : X86_ast.arg -> X86_ast.arg -> unitval sub : X86_ast.arg -> X86_ast.arg -> unitval subsd : X86_ast.arg -> X86_ast.arg -> unitval test : X86_ast.arg -> X86_ast.arg -> unitval ucomisd : X86_ast.arg -> X86_ast.arg -> unitval xchg : X86_ast.arg -> X86_ast.arg -> unitval xor : X86_ast.arg -> X86_ast.arg -> unitval xorpd : X86_ast.arg -> X86_ast.arg -> unitX86_dslHelpers for Intel code generators
val sym : string -> X86_ast.argval nat : nativeint -> X86_ast.argval int : int -> X86_ast.argval const_32 : int32 -> X86_ast.constantval const_nat : nativeint -> X86_ast.constantval const : int -> X86_ast.constantval al : X86_ast.argval ah : X86_ast.argval cl : X86_ast.argval ax : X86_ast.argval rax : X86_ast.argval r10 : X86_ast.argval r11 : X86_ast.argval r13 : X86_ast.argval r14 : X86_ast.argval r15 : X86_ast.argval rsp : X86_ast.argval rbp : X86_ast.argval xmm15 : X86_ast.argval eax : X86_ast.argval ebx : X86_ast.argval ecx : X86_ast.argval edx : X86_ast.argval ebp : X86_ast.argval esp : X86_ast.argval st0 : X86_ast.argval st1 : X86_ast.argval mem32 :
+ X86_ast.data_type ->
+ ?scale:int ->
+ ?base:X86_ast.reg64 ->
+ ?sym:string ->
+ int ->
+ X86_ast.reg64 ->
+ X86_ast.argval mem64 :
+ X86_ast.data_type ->
+ ?scale:int ->
+ ?base:X86_ast.reg64 ->
+ ?sym:string ->
+ int ->
+ X86_ast.reg64 ->
+ X86_ast.argval mem64_rip : X86_ast.data_type -> ?ofs:int -> string -> X86_ast.argmodule D : sig ... endDirectives
module I : sig ... endX86_gasEmit assembly instructions for gas.
val generate_asm : out_channel -> X86_ast.asm_line list -> unitX86_masmEmit assembly instructions for MASM (Intel syntax).
val generate_asm : out_channel -> X86_ast.asm_line list -> unitX86_procDefinitions shared between the 32 and 64 bit Intel backends.
Helpers for textual emitters
val string_of_reg8l : X86_ast.reg64 -> stringval string_of_reg8h : X86_ast.reg8h -> stringval string_of_reg16 : X86_ast.reg64 -> stringval string_of_reg32 : X86_ast.reg64 -> stringval string_of_reg64 : X86_ast.reg64 -> stringval string_of_registerf : X86_ast.registerf -> stringval string_of_condition : X86_ast.condition -> stringval string_of_rounding : X86_ast.rounding -> stringval buf_bytes_directive : Stdlib.Buffer.t -> string -> string -> unitBuffer of assembly code
val emit : X86_ast.instruction -> unitval directive : X86_ast.asm_line -> unitCode emission
val generate_code : (X86_ast.asm_line list -> unit) option -> unitPost-process the stream of instructions. Dump it (using the provided syntax emitter) in a file (if provided) and compile it with an internal assembler (if registered through register_internal_assembler).
Generate an object file corresponding to the last call to generate_code. An internal assembler is used if available (and the input file is ignored). Otherwise, the source asm file with an external assembler.
System detection
val system : systemSupport for plumbing a binary code emitter
val register_internal_assembler :
+ (X86_ast.asm_program -> string -> unit) ->
+ unitval with_internal_assembler :
+ (X86_ast.asm_program -> string -> unit) ->
+ (unit -> 'a) ->
+ 'aBigarray CamlinternalAtomic CamlinternalFormat CamlinternalFormatBasics CamlinternalLazy Run-time support for lazy values. All functions in this module are for system use only, not for the casual user.CamlinternalMod Run-time support for recursive modules. All functions in this module are for system use only, not for the casual user.CamlinternalOO Run-time support for objects and classes. All functions in this module are for system use only, not for the casual user.Dynlink Dynamic loading of .cmo, .cma and .cmxs files.Profiling Std_exit Stdlib The OCaml Standard library.Str Regular expressions and high-level string processingTopdirs Unix Interface to the Unix system.UnixLabels Interface to the Unix system.Condition Condition variables to synchronize between threads.Event First-class synchronous communication.Mutex Locks for mutual exclusion.Semaphore SemaphoresThread Lightweight threads for Posix 1003.1c and Win32.ThreadUnix Thread-compatible system calls.Afl_instrument Instrumentation for afl-fuzz.Alias_analysis Allocated_const Constants that are always allocated (possibly statically). Blocks are not included here since they are always encoded using Prim (Pmakeblock, ...).Annot Arch Arg_helper Decipher command line arguments of the form <value> | <key>=<value>,...Asmgen From Lambda to assembly codeAsmlibrarian Asmlink Asmpackager Ast_helper Helpers to produce Parsetree fragmentsAst_invariants Check AST invariantsAst_iterator Ast_iterator.iterator enables AST inspection using open recursion. A typical mapper would be based on Ast_iterator.default_iterator, a trivial iterator, and will fall back on it for handling the syntax it does not modify.Ast_mapper The interface of a -ppx rewriterAsttypes Auxiliary AST types used by parsetree and typedtree.Attr_helper Helpers for attributesAugment_specialised_args Helper module for adding specialised arguments to sets of closures.Backend_intf Knowledge that the middle end needs about the backend.Backend_var Variables used in the backend, optionally equipped with "provenance" information, used for the emission of debugging information.Binutils Branch_relaxation Branch_relaxation_intf Btype Build_export_info Construct export information, for emission into .cmx files, from an Flambda program.Build_path_prefix_map Rewrite paths for reproducible buildsBuiltin_attributes Support for some of the builtin attributesBytegen Bytelibrarian Bytelink Bytepackager Bytesections Recording sections written to a bytecode executable fileCSE CSEgen CamlinternalMenhirLib Ccomp Compiling C files and building C librariesClambda Clambda_primitives Clflags Command line flagsClosure Closure_conversion Closure_conversion_aux Environments and auxiliary structures used during closure conversion.Closure_element Closure_id CR-someday lwhite: "Closure_id" is quite a generic name. I wonder whether something like "Closure_label" would better capture that it is the label of a projection.Closure_middle_end Closure_offsets Assign numerical offsets, within closure blocks, for code pointers and environment entries.Closure_origin Cmi_format Cmm Cmm_helpers Cmm_invariants run ppf fundecl analyses the given function, and returns whether any errors were encountered (with corresponding error messages printed on the given formatter).Cmmgen Cmmgen_state Mutable state used by Cmmgen.Cmo_format Cmt2annot Cmt_format cmt and cmti files format.Cmx_format Cmxs_format Coloring Comballoc Compenv Compilation_unit Compile Bytecode compilation for .ml and .mli files.Compile_common Common compilation pipeline between bytecode and native.Compilenv Compmisc Config System configurationConsistbl Consistency tables: for checking consistency of module CRCsConvert_primitives Ctype Dataflow Datarepr Deadcode Debuginfo Depend Module dependencies.Diffing Parametric diffingDiffing_with_keys When diffing lists where each element has a distinct key, we can refine the diffing patch by introducing two composite edit moves: swaps and moves.Dll Docstrings Documentation commentsDomainstate Effect_analysis Simple side effect analysis.Emit Emitaux Emitcode Emitenv Env Envaux Errors Errortrace Export_id Export_info Exported information (that is to say, information written into a .cmx file) about a compilation unit.Export_info_for_pack Transformations on export information that are only used for the building of packs.Expunge Extract_projections Identify projections from variables used in function bodies (free variables or specialised args, for example, according to which_variables below). Projections from variables that are also used boxed are not returned.Find_recursive_functions "Recursive functions" are those functions f that might call either:Flambda Intermediate language used for tree-based analysis and optimization.Flambda_invariants Flambda_iterators Flambda_middle_end Translate Lambda code to Flambda code, optimize it, and produce Clambda.Flambda_to_clambda Flambda_utils Utility functions for the Flambda intermediate language.Freshening Freshening of various identifiers.Genprintval Id_types Ident Identifiable Uniform interface for common data structures over various things.Import_approx Create simple value approximations from the export information in .cmx files.Includeclass Includecore Includemod Includemod_errorprinter Inconstant_idents Initialize_symbol_to_let_symbol Inline_and_simplify Inline_and_simplify_aux Environments and result structures used during inlining and simplification. (See inline_and_simplify.ml.)Inlining_cost Measurement of the cost (including cost in space) of Flambda terms in the context of inlining.Inlining_decision See the Flambda manual chapter for an explanation in prose of the inlining decision procedure.Inlining_decision_intf Inlining_stats Inlining_stats_types Inlining_transforms Source code transformations used during inlining.Instruct Int_replace_polymorphic_compare Interf Internal_variable_names Interval Invariant_params Lambda Lazy_backtrack Lexer The lexical analyzerLift_code Lift_constants The aim of this pass is to assign symbols to values known to be constant (in other words, whose values we know at compile time), with appropriate sharing of constants, and replace the occurrences of the constants with their corresponding symbols.Lift_let_to_initialize_symbol Linear Linear_format Linearize Linkage_name Linscan Liveness Load_path Management of include directories.Local_store This module provides some facilities for creating references (and hash tables) which can easily be snapshoted and restored to an arbitrary version.Location Source code locations (ranges of positions), used in parsetree.Longident Long identifiers, used in parsetree.Mach Main Main_args Maindriver Makedepend Matching Meta Misc Miscellaneous useful types and functionsMtype Mutable_variable Numbers Modules about numbers, some of which satisfy Identifiable.S.Opcodes Oprint Optcompile Native compilation for .ml and .mli files.Opterrors Optmain Optmaindriver Outcometree Parameter Parameter.t carries a unique Variable.t used as function parameter. It can also carry annotations about the usage of the variable.Parmatch Detection of partial matches and unused match cases.Parse Entry points in the parserParser Parsetree Abstract syntax tree produced by parsingPass_wrapper Path Patterns Persistent_env Polling Analyses related to the insertion of Ipoll operations.Pparse Driver for the parser and external preprocessors.Pprintast Pretty-printers for ParsetreePredef Primitive Printast Raw printer for ParsetreePrintclambda Printclambda_primitives Printcmm Printinstr Printlambda Printlinear Printmach Printpat Printtyp Printtyped Proc Profile Compiler performance recordingProjection Representation of projections from closures and blocks.Rec_check Ref_to_variables Transform let-bound references into variables.Reg Reload Reloadgen Remove_free_vars_equal_to_args Replace free variables in closures known to be equal to specialised arguments of such closures with those specialised arguments.Remove_unused_arguments Remove_unused_closure_vars Remove_unused_program_constructs Runtimedef Schedgen Scheduling Selectgen Selection Semantics_of_primitives Description of the semantics of primitives, to be used for optimization purposes.Set_of_closures_id An identifier, unique across the whole program, that identifies a set of closures (viz. Set_of_closures).Set_of_closures_origin Shape Share_constants Share lifted constants that are eligible for sharing (e.g. not strings) and have equal definitions.Signature_group Iterate on signature by syntactic group of itemsSimple_value_approx Simple approximations to the runtime results of computations. This pass is designed for speed rather than accuracy; the performance is important since it is used heavily during inlining.Simplif Lambda simplification.Simplify_boxed_integer_ops Simplify_boxed_integer_ops_intf Simplify_common const_*_expr expr v annot, where the expression expr is known to evaluate to the value v, attempt to produce a more simple expression together with its approximation and the benefit gained by replacing expr with this new expression. This simplification is only performed if expr is known to have no side effects. Otherwise, expr itself is returned, with an appropriate approximation but zero benefit.Simplify_primitives Spill Split Static_exception An identifier that is used to label static exceptions. Its uniqueness properties are unspecified.Strmatch Strongly_connected_components Kosaraju's algorithm for strongly connected components.Stypes Subst Switch Symbol A symbol identifies a constant provided by either:Symtable Syntaxerr Auxiliary type for reporting syntax errorsTag Tags on runtime boxed values.Targetint Target processor-native integers.Tast_iterator Allows the implementation of typed tree inspection using open recursionTast_mapper Terminfo Basic interface to the terminfo databaseTmc Tail-modulo-cons optimization.Topcommon This module provides common implementations for internals of Toploop, for bytecode and native code (see Topeval for the diverging parts of the implementation).Topdirs Topeval This module provides two alternative implementations for internals of Toploop, for bytecode and native code.Tophooks Toploop Topmain Topstart Trace Translattribute Translclass Translcore Translmod Translobj Translprim Traverse_for_exported_symbols Type_immediacy Immediacy status of a typeTypeclass Typecore Typedecl Typedecl_immediacy Typedecl_properties Typedecl_separability The OCaml runtime assumes for type-directed optimizations that all types are "separable". A type is "separable" if either all its inhabitants (the values of this type) are floating-point numbers, or none of them are.Typedecl_unboxed Typedecl_variance Typedtree Abstract syntax tree after typingTypemod Type-checking of the module language and typed ast hooksTypeopt Types Typetexp Un_anf Unbox_closures Turn free variables of closures into specialised arguments. The aim is to cause the closure to become closed.Unbox_free_vars_of_closures When approximations of free variables of closures indicate that they are closures or blocks, rewrite projections from such blocks to new variables (which become free in the closures), with the defining expressions of the projections lifted out of the corresponding sets of closures.Unbox_specialised_args When approximations of specialised arguments indicate that they are closures or blocks, add more specialised arguments corresponding to the projections from such blocks (with definitions of such projections lifted out), such that the original specialised arguments may later be eliminated.Untypeast Var_within_closure An identifier, unique across the whole program, that identifies a particular variable within a particular closure. Only Project_var, and not Var, nodes are tagged with these identifiers.Variable Variable.t is the equivalent of a non-persistent Ident.t in the Flambda tree. It wraps an Ident.t together with its source compilation_unit. As such, it is unique within a whole program, not just one compilation unit.Warnings Warning definitionsX86_ast Structured representation of Intel assembly language (32 and 64 bit).X86_dsl Helpers for Intel code generatorsX86_gas Emit assembly instructions for gas.X86_masm Emit assembly instructions for MASM (Intel syntax).X86_proc Definitions shared between the 32 and 64 bit Intel backends.| changes-files | |
| license-files | |
| readme-files |