_LIBS
+ * add Lwt_unix.on_signal_full
+
+===== 2.4.1 (2012-08-22) =====
+
+ * Add Lwt_stream.on_terminate
+ * Fix Lwt_gc
+ * Fix stubs for get_credentials on *BSD
+
+===== 2.4.0 (2012-07-16) =====
+
+ * Reimplement Lwt_stream
+ - much simpler and more efficient
+ - do not use Weak
+ - add bounded push streams
+ * Add Lwt.async
+ * Add Lwt_preemptive.run_in_main
+ * Implement Lwt_unix.get_credentials on MacOS X/OpenBSD
+ * Ensure that on_cancel functions are executed first
+ * Better implementation of Lwt.cancel with more tests
+ * Simplify the API for unix jobs
+ * Better handling of the master lock in libev stubs
+ * Windows fixes/updates:
+ - pass -lws2_32 instead of ws2_32.lib if building with mingw
+ - fix a bug causing Lwt_unix.read/write to block when a socket
+ is not readable/writable
+ - port Lwt_process and Lwt_unix.system to Windows
+ * Compatibility with OCaml 4.00:
+ - add O_SHARE_DELETE to Lwt_unix.open_flag
+ - add -package compiler-libs.toplevel for files using Toploop
+ * Do not use module Sys for signal handling to avoid
+ OCaml code to be called in a C thread
+ * Fix Lwt_unix.wrap_syscall: try instead of Lwt.catch
+ * Fix a dead-lock between lwt_unix_send_notification
+ and lwt_unix_recv_notifications
+ * Fix #277: add a function to return the Ssl.socket of a Lwt_ssl.socket
+ * Fix problems with C libraries detection/linking
+
+===== 2.3.2 (2011-11-04) =====
+
+ * Add location informations in logs:
+ ** allow loggers to get the current location through local storage
+ ** pass current location to logging functions
+ ** pass the current location with the syntax extension
+ * Add Lwt.on_termination
+ * Add Lwt_unix.reinstall_signal_handler
+ * Add Lwt_io.flush_all
+ * Add assert_lwt keyword to the syntax extension
+ * Add Lwt.wrap
+ * Add Lwt_glib.iter and Lwt_glib.wakeup
+ * OCaml 3.13 ready
+ * Allow to compile without libev support
+ * Fix bugs in Lwt_io
+ * Better handling of forks
+ * Fix many problems on Windows
+
+===== 2.3.1 (2011-07-13) =====
+
+ * Fix building of documentation when using the tarball
+ * Add Lwt_unix.fsync and Lwt_unix.fdatasync
+ * Fix the stubs for Lwt_unix.send_msg when fd-passing is not
+ available
+ * Add -lwt-sequence-strict option to the syntax extension
+ * Use a custom PRNG state for Lwt.choose and Lwt.pick
+ * Fix a display glitch when starting the toplevel
+ * Add Lwt_unix.fork which should now be used when one want to use
+ Lwt in the child process
+ * Better implementation of Lwt_unix.readlink and
+ Lwt_unix.gethostbyname, which fixes compilation on Hurd
+ * Add Lwt.wakeup_later and Lwt.wakeup_later_exn to be used when one
+ need to do lot of nested wakeup, which fixes a buffer overflow in
+ Lwt_mutex
+ * Fix Lwt_unix.abort and Lwt_unix.close (threads was never wakeup)
+ * Fix Lwt_throttle for correct timings
+ * Fix subtle use of cancel
+
+===== 2.3.0 (2011-04-12) =====
+
+ * Add an extensible system of engines to:
+ ** allow the user to replace libev by another event system, such
+ as select
+ ** allow easier integration of external libraries supporting
+ asynchronous operations
+ * Lots of improvements for Windows:
+ ** use the OCaml select instead of libev by default on Windows
+ ** make asynchronous operations on non-socket file descriptors
+ such as pipes to work
+ ** make glib integration to work
+ * Better use of engines in Lwt_unix: now events are cached to minimize
+ the amount of calls to epoll_ctl
+ * Use an eventfd when possible for notifications for faster delivery
+ * Add modules:
+ ** Lwt_sys: allow to test availability of extra features
+ ** Lwt_react: replace Lwt_event and Lwt_signal
+ * Allow to configure logging rules at runtime in Lwt_log
+ * Add match_lwt and while_lwt to the syntax extension
+ * Fixes:
+ ** syntax extension: handle "lwt ... = ... in ..." at toplevel
+ ** make the notification system fork-proof
+ ** fix an issue with stubs not raising correctly exceptions
+
+===== 2.2.1 (2011-01-26) =====
+
+ * Better interaction with Js_of_OCaml.
+ * Add functions {{{Lwt.register_pause_notifier}}} and {{{Lwt.paused_count}}}.
+
+===== 2.2.0 (2010-12-13) =====
+
+ * Bugfixes:
+ ** Fix a bug with cancellable threads causing {{{Canceled}}}
+ exceptions to be raised randomly
+ ** Fix a fd-leak in Lwt_io.open_connection
+ * {{{Lwt_unix}}} now use libev instead of select
+ * Add thread local storage support to {{{Lwt}}}
+ * Add backtrace support to {{{Lwt}}}. Now {{{Lwt}}} exceptions can
+ be recorded by using the syntax extension with the {{{-lwt-debug}}}
+ command line switch.
+ * Allow blocking system calls to be executed in parallels
+ * Change the type of many functions of {{{Lwt_unix}}}, which now
+ return a {{{Lwt}}} thread
+ * Add functions {{{Lwt_unix.readable}}} and {{{Lwt_unix.writable}}}
+ * Add function {{{Lwt_io.is_busy}}}
+ * Add functions {{{Lwt_event.delay}}} and {{{Lwt_signal.delay}}}
+ * Add function {{{Lwt_term.render_update}}}
+ * Add function {{{Lwt_ssl.embed_socket}}}
+ * Add module {{{Lwt_bytes}}} defining operations on bigarrays
+ instead of strings
+ * Use bigarrays in Lwt_io instead of strings for the internal buffer.
+ Lwt_io.make now takes a function that uses a bigarray.
+ * Add module {{{Lwt_switch}}}
+
+===== 2.1.1 (2010-06-13) =====
+
+ * Many bugfixes, including:
+ ** buggy behaviour of cancellable threads
+ ** file descriptor leakage in {{{Lwt_unix.accept_n}}}
+ * Add {{{Lwt.nchoose}}} and {{{Lwt.npick}}}
+ * Use {{{set_close_on_exec}}} for fds created by {{{Lwt_log}}}
+ * Better implementation of lwtized react functions
+
+===== 2.1.0 (2010-04-19) =====
+
+ * Rename {{{Lwt.select}}} to {{{Lwt.pick}}}
+ * Removing module {{{Lwt_monitor}}} in favour of {{{Lwt_mutex}}} and
+ new module {{{Lwt_condition}}}
+ * More react helpers:
+ ** {{{Lwt_event.next}}}
+ ** {{{Lwt_event.limit}}} and {{{Lwt_signal.limit}}}
+ ** {{{Lwt_event.from}}}
+ * Adding function {{{Lwt_main.fast_yield}}}
+ * Adding unit tests
+ * Optimisation of {{{Lwt}}}
+ * Adding module {{{Lwt_log}}} for logging
+ * Adding a camlp4 filter for remmoving logging statement or inlining
+ tests
+ * Adding module {{{Lwt_daemon}}}
+ * Adding function {{{Lwt_unix.recv_msg}}} and {{{Lwt_unix.send_msg}}}
+ * Adding function {{{Lwt_unix.wait4}}}
+ * Adding function {{{Lwt_io.establish_server}}}
+ * Adding module {{{Lwt_list}}}
+ * Enhancement in {{{Lwt_process}}}, it now support redirections and
+ timeouts
+ * Allow to use {{{select}}} on arbitrary high file descriptors
+ * More commands and features in {{{Lwt_read_line}}}:
+ ** Handle "undo" command
+ ** New controllable read-lines instances
+ ** More edition commands
+ ** Completion as you type
+ ** Backward search
+ * Enhancement in {{{Lwt_term}}}: more drawing functions and allow to
+ put the terminal into drawing mode
+ * Optimisation of {{{Lwt_stream}}}
+ * Optimisation of {{{Lwt_io.write_char}}} and {{{Lwt_io.read_char}}}
+ * Bugfix of {{{Lwt_stream}}}: two parallel {{{Lwt_stream.get}}}
+ returned the same value
+ * Bugfix in {{{Lwt_unix.connect}}}: it returned immediately on EINPROGRESS
+ * Bugfixes in {{{Lwt_glib}}}: file descriptors were not monitored correctly
+
+===== 2.0.0 (2009-10-15) =====
+
+ * Adding modules:
+ ** {{{Lwt_stream}}}: lwt-aware version of the {{{Stream}}} module
+ ** {{{Lwt_gc}}} for using {{{finalise}}} without
+ {{{Lwt_unix.run}}}
+ ** {{{Lwt_io}}}: a new implementation of buffered channels with
+ more features and better handling of concurrent access
+ ** {{{Lwt_text}}}: implementation of text channels
+ ** {{{Lwt_process}}}: helpers to spawn processes and communicate
+ with them
+ ** {{{Lwt_main}}} for abstracting the main loop and allowing
+ replacement by a custom main loop
+ ** {{{Lwt_glib}}} for integration into the glib main event loop
+ ** {{{Lwt_term}}} for interaction with the terminal
+ ** {{{Lwt_read_line}}} for interactive user input
+ ** {{{Lwt_monitor}}}, {{{Lwt_mvar}}}: combined locks for
+ synchronization with conditional variables for notification
+ ** {{{Lwt_throttle}}} for limiting rate of execution
+ (e.g. for authentication procedure)
+ ** {{{Lwt_sequence}}}: mutable sequence of elements
+ ** {{{Lwt_event}}}, {{{Lwt_signal}}}: helpers for reactive
+ programming with lwt
+ * Adding a syntax extension {{{pa_lwt}}}:
+ ** handles anonymous bind {{{a >> b}}}
+ ** adds syntactic sugar for catching errors (ticket #6)
+ ** adds syntactic sugar for parallel let-binding construction
+ ** adds syntactic sugar for for-like loops
+ * Top-level integration:
+ ** threads can runs while reading user input
+ ** line editing support
+ * New enhanced OCaml toplevel with some basic completion features
+ * Adding C stubs to reimplement {{{Unix.read}}} and {{{Unix.write}}}
+ with assumption of non-blocking behaviour
+ * Adding more functions/helpers in {{{Lwt}}}
+ * Fixing memory leaks in {{{Lwt.choose}}}
+ * Bugfix in {{{Lwt_chan.close_*}}} (ticket #66)
+ * Separate the type of threads (covariant) from the type of thread
+ wakeners (contravariant); the type of many functions related to
+ {{{Lwt.wait}}} has been changed
+ * Add cancelable threads
+ * Unix-dependent part is now put in its own archive and findlib
+ package.
+
+===== 1.1.0 (2008-06-25) =====
+
+ * Adding module {{{Lwt_pool}}} for creating pools (for example pools
+ of connections)
+ * Adding a few functions in {{{Lwt_chan}}}
+ * Fixing bugs in {{{Lwt_util.map_serial}}} and
+ {{{Lwt_util.iter_serial}}}
+ * Putting {{{Lwt_preemptive}}}, {{{Lwt_lib}}} and {{{Lwt_ssl}}} in
+ separate libraries and findlib subpackages so that lwt.cma depends
+ only on unix.cma.
+
+===== 1.0.0 (and before) =====
+
+ * See Ocsigen changelog
diff --git a/lwt/_doc-dir/LICENSE.md b/lwt/_doc-dir/LICENSE.md
new file mode 100644
index 00000000..0c2afacb
--- /dev/null
+++ b/lwt/_doc-dir/LICENSE.md
@@ -0,0 +1,19 @@
+Copyright (c) 1999-2020, the Authors of Lwt (docs/AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/lwt/_doc-dir/README.md b/lwt/_doc-dir/README.md
new file mode 100644
index 00000000..1c94c14d
--- /dev/null
+++ b/lwt/_doc-dir/README.md
@@ -0,0 +1,187 @@
+# Lwt
+
+[![version][version]][releases] [![GitHub Actions status][github-actions-img]][github-actions]
+
+[version]: https://img.shields.io/github/release/ocsigen/lwt
+[releases]: https://github.com/ocsigen/lwt/releases
+[github-actions]: https://github.com/ocsigen/lwt/actions
+[github-actions-img]: https://github.com/ocsigen/lwt/actions/workflows/workflow.yml/badge.svg?branch=master
+[appveyor]: https://ci.appveyor.com/project/aantron/lwt/branch/master
+[appveyor-img]: https://img.shields.io/appveyor/ci/aantron/lwt/master.svg?label=appveyor
+
+Lwt is a concurrent programming library for OCaml. It provides a single data
+type: the *promise*, which is a value that will become determined in the future.
+Creating a promise spawns a computation. When that computation is I/O, Lwt runs
+it in parallel with your OCaml code.
+
+OCaml code, including creating and waiting on promises, is run in a single
+thread by default, so you don't have to worry about locking or preemption. You
+can detach code to be run in separate threads on an opt-in basis.
+
+Here is a simplistic Lwt program which requests the Google front page, and fails
+if the request is not completed in five seconds:
+
+```ocaml
+open Lwt.Syntax
+
+let () =
+ let request =
+ let* addresses = Lwt_unix.getaddrinfo "google.com" "80" [] in
+ let google = Lwt_unix.((List.hd addresses).ai_addr) in
+
+ Lwt_io.(with_connection google (fun (incoming, outgoing) ->
+ let* () = write outgoing "GET / HTTP/1.1\r\n" in
+ let* () = write outgoing "Connection: close\r\n\r\n" in
+ let* response = read incoming in
+ Lwt.return (Some response)))
+ in
+
+ let timeout =
+ let* () = Lwt_unix.sleep 5. in
+ Lwt.return None
+ in
+
+ match Lwt_main.run (Lwt.pick [request; timeout]) with
+ | Some response -> print_string response
+ | None -> prerr_endline "Request timed out"; exit 1
+
+(* ocamlfind opt -package lwt.unix -linkpkg example.ml && ./a.out *)
+```
+
+In the program, functions such as `Lwt_io.write` create promises. The
+`let* ... in` construct is used to wait for a promise to become determined; the
+code after `in` is scheduled to run in a "callback." `Lwt.pick` races promises
+against each other, and behaves as the first one to complete. `Lwt_main.run`
+forces the whole promise-computation network to be executed. All the visible
+OCaml code is run in a single thread, but Lwt internally uses a combination of
+worker threads and non-blocking file descriptors to resolve in parallel the
+promises that do I/O.
+
+
+index (lwt.index) Up – lwtLwt is a concurrent programming library for OCaml. It provides a single data type: the promise , which is a value that will become determined in the future. Creating a promise spawns a computation. When that computation is I/O, Lwt runs it in parallel with your OCaml code.
OCaml code, including creating and waiting on promises, is run in a single thread by default, so you don't have to worry about locking or preemption. You can detach code to be run in separate threads on an opt-in basis.
Here is a simplistic Lwt program which requests the Google front page, and fails if the request is not completed in five seconds:
open Lwt.Syntax
+
+let () =
+ let request =
+ let* addresses = Lwt_unix.getaddrinfo "google.com" "80" [] in
+ let google = Lwt_unix.((List.hd addresses).ai_addr) in
+
+ Lwt_io.(with_connection google (fun (incoming, outgoing) ->
+ let* () = write outgoing "GET / HTTP/1.1\r\n" in
+ let* () = write outgoing "Connection: close\r\n\r\n" in
+ let* response = read incoming in
+ Lwt.return (Some response)))
+ in
+
+ let timeout =
+ let* () = Lwt_unix.sleep 5. in
+ Lwt.return None
+ in
+
+ match Lwt_main.run (Lwt.pick [request; timeout]) with
+ | Some response -> print_string response
+ | None -> prerr_endline "Request timed out"; exit 1
+
+(* ocamlfind opt -package lwt.unix -linkpkg example.ml && ./a.out *)In the program, functions such as Lwt_io.write create promises. The let%lwt ... in construct is used to wait for a promise to become determined; the code after in is scheduled to run in a "callback." Lwt.pick races promises against each other, and behaves as the first one to complete. Lwt_main.run forces the whole promise-computation network to be executed. All the visible OCaml code is run in a single thread, but Lwt internally uses a combination of worker threads and non-blocking file descriptors to resolve in parallel the promises that do I/O.
Lwt compiles to native code on Linux, macOS, Windows, and other systems. It's also routinely compiled to JavaScript for the front end and Node by js_of_ocaml.
In Lwt,
Use your system package manager to install a development libev package. It is often called libev-dev or libev-devel. opam install conf-libev lwtlwtThis is the system-independent, pure-OCaml core of Lwt. To link with it, use (libraries lwt) in your dune file.
lwt.unixThis is the system call and I/O library. Despite its name, it is implemented on both Unix-like systems and Windows, although not all functions are available on Windows. To link with this library, use (libraries lwt.unix) in your dune file.
Afl_instrument (ocaml.Afl_instrument) Up – ocaml » Afl_instrumentAlias_analysis (ocaml.Alias_analysis) Up – ocaml » Alias_analysisSimple 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.
Allocated_const (ocaml.Allocated_const) Up – ocaml » Allocated_consttype t = | Float of float| Int32 of int32| Int64 of int64| Nativeint of nativeint| Float_array of float list | Immutable_float_array of float list | String of string| Immutable_string of stringval compare_floats : float -> float -> intval compare : t -> t -> Annot (ocaml.Annot) Up – ocaml » Annottype call = | Tail | Stack | Inline Arch (ocaml.Arch) Up – ocaml » Archtype addressing_mode = | Ibased of string * int| Iindexed of int| Iindexed2 of int| Iscaled of int * int| Iindexed2scaled of int * intand float_operation = | Ifloatadd | Ifloatsub | Ifloatmul | Ifloatdiv val allow_unaligned_access : boolval division_crashes_on_overflow : boolMap (ocaml.Arg_helper.Make.S.Key.Map) Up – ocaml » Arg_helper » Make » S » Key » MapThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Key (ocaml.Arg_helper.Make.S.Key) Up – ocaml » Arg_helper » Make » S » Keyval of_string : string -> t The textual representation of a key must not contain '=' or ','.
Value (ocaml.Arg_helper.Make.S.Value) Up – ocaml » Arg_helper » Make » S » Valueval of_string : string -> t The textual representation of a value must not contain ','.
S (ocaml.Arg_helper.Make.S) Up – ocaml » Arg_helper » Make » Smodule Value : sig ... end Make (ocaml.Arg_helper.Make) Up – ocaml » Arg_helper » Makeval parse : string -> string -> parsed ref -> type parse_result = | Ok | Parse_failed of exnArg_helper (ocaml.Arg_helper) Up – ocaml » Arg_helperModule Arg_helper Decipher 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 .
module Make (S : sig ... end ) : sig ... end Asmgen (ocaml.Asmgen) Up – ocaml » AsmgenThe type of converters from Lambda to Clambda.
Compile an implementation from Lambda using the given middle end.
val compile_implementation_linear : string -> progname :string -> type error = | Assembler_error of string| Mismatched_for_pack of string option | Asm_generation of string * Emitaux.error val compile_unit :
+ output_prefix :string -> asm_filename :string -> keep_asm :bool -> obj_filename :string -> (unit -> unit) -> Asmlibrarian (ocaml.Asmlibrarian) Up – ocaml » Asmlibrarianval create_archive : string list -> string -> unittype error = | File_not_found of string| Archiver_error of stringAsmlink (ocaml.Asmlink) Up – ocaml » Asmlinkval call_linker_shared : string list -> string -> unit
Asmpackager (ocaml.Asmpackager) Up – ocaml » Asmpackagertype error = | Illegal_renaming of string * string * string| Forward_reference of string * string| Wrong_for_pack of string * string| Linking_error | Assembler_error of string| File_not_found of stringAttr (ocaml.Ast_helper.Attr) Up – ocaml » Ast_helper » AttrCf (ocaml.Ast_helper.Cf) Up – ocaml » Ast_helper » CfModule Ast_helper.Cf Class fields
Ci (ocaml.Ast_helper.Ci) Up – ocaml » Ast_helper » CiModule Ast_helper.Ci Classes
Cl (ocaml.Ast_helper.Cl) Up – ocaml » Ast_helper » ClModule Ast_helper.Cl Class expressions
Const (ocaml.Ast_helper.Const) Up – ocaml » Ast_helper » ConstCsig (ocaml.Ast_helper.Csig) Up – ocaml » Ast_helper » CsigModule Ast_helper.Csig Class signatures
Cstr (ocaml.Ast_helper.Cstr) Up – ocaml » Ast_helper » CstrModule Ast_helper.Cstr Class structures
Ctf (ocaml.Ast_helper.Ctf) Up – ocaml » Ast_helper » CtfModule Ast_helper.Ctf Class type fields
Cty (ocaml.Ast_helper.Cty) Up – ocaml » Ast_helper » CtyModule Ast_helper.Cty Class type expressions
Exp (ocaml.Ast_helper.Exp) Up – ocaml » Ast_helper » ExpModule Ast_helper.Exp Expressions
Incl (ocaml.Ast_helper.Incl) Up – ocaml » Ast_helper » InclModule Ast_helper.Incl Includes
Mb (ocaml.Ast_helper.Mb) Up – ocaml » Ast_helper » MbModule Ast_helper.Mb Module bindings
Md (ocaml.Ast_helper.Md) Up – ocaml » Ast_helper » MdModule Ast_helper.Md Module declarations
Mod (ocaml.Ast_helper.Mod) Up – ocaml » Ast_helper » ModModule Ast_helper.Mod Module expressions
Ms (ocaml.Ast_helper.Ms) Up – ocaml » Ast_helper » MsModule Ast_helper.Ms Module substitutions
Mtd (ocaml.Ast_helper.Mtd) Up – ocaml » Ast_helper » MtdModule Ast_helper.Mtd Module type declarations
Mty (ocaml.Ast_helper.Mty) Up – ocaml » Ast_helper » MtyModule Ast_helper.Mty Module type expressions
Of (ocaml.Ast_helper.Of) Up – ocaml » Ast_helper » OfModule Ast_helper.Of Object fields
Opn (ocaml.Ast_helper.Opn) Up – ocaml » Ast_helper » OpnModule Ast_helper.Opn Opens
Pat (ocaml.Ast_helper.Pat) Up – ocaml » Ast_helper » PatModule Ast_helper.Pat Patterns
Rf (ocaml.Ast_helper.Rf) Up – ocaml » Ast_helper » RfModule Ast_helper.Rf Row fields
Sig (ocaml.Ast_helper.Sig) Up – ocaml » Ast_helper » SigModule Ast_helper.Sig Signature items
Str (ocaml.Ast_helper.Str) Up – ocaml » Ast_helper » StrModule Ast_helper.Str Structure items
Te (ocaml.Ast_helper.Te) Up – ocaml » Ast_helper » TeModule Ast_helper.Te Type extensions
Typ (ocaml.Ast_helper.Typ) Up – ocaml » Ast_helper » TypModule Ast_helper.Typ Type expressions
varify_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.
Type (ocaml.Ast_helper.Type) Up – ocaml » Ast_helper » TypeModule Ast_helper.Type Type declarations
Val (ocaml.Ast_helper.Val) Up – ocaml » Ast_helper » ValModule Ast_helper.Val Value declarations
Vb (ocaml.Ast_helper.Vb) Up – ocaml » Ast_helper » VbModule Ast_helper.Vb Value bindings
Ast_helper (ocaml.Ast_helper) Up – ocaml » Ast_helperDefault value for all optional location arguments.
val with_default_loc : loc -> (unit -> 'a ) -> 'a Set the default_loc within the scope of the execution of the provided function.
module Const : sig ... end module Attr : sig ... end module Type : sig ... end module Incl : sig ... end module Csig : sig ... end module Cstr : sig ... end Ast_invariants (ocaml.Ast_invariants) Up – ocaml » Ast_invariantsAst_iterator (ocaml.Ast_iterator) Up – ocaml » Ast_iteratorModule Ast_iterator Ast_iterator.iteratorAst_iterator.default_iterator
Warning: this module is unstable and part of compiler-libs .
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.
A default iterator, which implements a "do not do anything" mapping.
Ast_mapper (ocaml.Ast_mapper) Up – ocaml » Ast_mapperModule Ast_mapper The 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.
mapperdefault_mapper
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 .
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.
A default mapper, which implements a "deep identity" mapping.
val apply : source :string -> target :string -> mapper -> Apply 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 ) -> Entry 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
val register_function : (string -> (string list -> mapper ) -> ref val register : string -> (string list -> mapper ) -> Apply 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 map_opt : ('a -> 'b ) -> 'a option-> 'b optionEncode 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.
Encode 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.structure Extract 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 drop_ppx_context_str :
+ restore :bool -> Parsetree.structure -> Parsetree.structure Drop the ocaml.ppx.context attribute from a structure. If restore is true, also restore the associated data in the current process.
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).
Asttypes (ocaml.Asttypes) Up – ocaml » AsttypesModule Asttypes Auxiliary 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 nativeinttype rec_flag = | Nonrecursive | Recursive type direction_flag = | Upto | Downto type private_flag = | Private | Public type mutable_flag = | Immutable | Mutable type virtual_flag = | Virtual | Concrete type override_flag = | Override | Fresh type closed_flag = | Closed | Open type arg_label = | Nolabel | Labelled of string| Optional of stringtype variance = | Covariant | Contravariant | NoVariance type injectivity = | Injective | NoInjectivity Attr_helper (ocaml.Attr_helper) Up – ocaml » Attr_helpertype error = | Multiple_attributes of string| No_payload_expected of stringThe 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"]Definition (ocaml.Augment_specialised_args.Definition) Up – ocaml » Augment_specialised_args » DefinitionModule Augment_specialised_args.Definition _ (ocaml.Augment_specialised_args.Make._) Up – ocaml » Augment_specialised_args » Make » _Make (ocaml.Augment_specialised_args.Make) Up – ocaml » Augment_specialised_args » MakeModule Augment_specialised_args.Make duplicate_function should be Inline_and_simplify.duplicate_function.
What_to_specialise (ocaml.Augment_specialised_args.What_to_specialise) Up – ocaml » Augment_specialised_args » What_to_specialiseModule Augment_specialised_args.What_to_specialise val make_direct_call_surrogate_for : t -> fun_var :Variable.t -> t Augment_specialised_args (ocaml.Augment_specialised_args) Up – ocaml » Augment_specialised_argsmodule type S = sig ... end module Make (_ : S ) : sig ... end S (ocaml.Augment_specialised_args.S) Up – ocaml » Augment_specialised_args » SModule type Augment_specialised_args.S Backend_intf (ocaml.Backend_intf) Up – ocaml » Backend_intfmodule type S = sig ... end S (ocaml.Backend_intf.S) Up – ocaml » Backend_intf » SModule type Backend_intf.S Compute the symbol for the given identifier.
If 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.
The natural size of an integer on the target architecture (cf. Arch.size_int in the native code backend).
true iff the target architecture is big endian.
val max_sensible_number_of_arguments : intThe maximum number of arguments that is reasonable for a function to have. This should be fewer than the threshold that causes non-self tail call optimization to be inhibited (in particular, if it would entail passing arguments on the stack; see Selectgen).
Provenance (ocaml.Backend_var.Provenance) Up – ocaml » Backend_var » ProvenanceModule Backend_var.Provenance With_provenance (ocaml.Backend_var.With_provenance) Up – ocaml » Backend_var » With_provenanceModule Backend_var.With_provenance Values of type t should be used for variables in binding position.
Backend_var (ocaml.Backend_var) Up – ocaml » Backend_varModule Backend_var Variables used in the backend, optionally equipped with "provenance" information, used for the emission of debugging information.
include module type of struct include Ident end include Identifiable.S with type t := t include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Same as printn" suffix if the scope of the argument is n.
val create_scoped : scope :int -> string -> t val create_local : string -> t val create_persistent : string -> t val create_predef : string -> t Creates an identifier with the same name as the input, a fresh stamp, and no scope.
val unique_name : t -> val unique_toplevel_name : t -> val persistent : t -> val same : t -> t -> Compare 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 compare : t -> t -> val is_predef : t -> val reinit : unit -> unit'a tbl represents association tables from identifiers to values of type 'a.
'a tbl plays the role of map, but bindings can be looked up from either the full Ident using find_same, or just its user-visible name using find_name. In general the two lookups may not return the same result, as an identifier may have been shadowed in the environment by a distinct identifier with the same name.
find_all returns the bindings for all idents of a given name, most recently introduced first.
In other words, 'a tbl corresponds to (Ident.t * 'a) list Map.Make(String) and the implementation is very close to that representation.
Note in particular that searching among idents of the same name takes linear time, and that add simply extends the list without checking for duplicates. So it is not a good idea to implement union by repeated add calls, which may result in many duplicated identifiers and poor find_same performance. It is even possible to build overly large same-name lists such that non-recursive functions like find_all or fold_all blow the stack.
You should probably use Map.Make(Ident) instead, unless you really need to query bindings by user-visible name, not just by unique identifiers.
val add : t -> 'a -> 'a tbl -> 'a tbl val find_same : t -> 'a tbl -> 'a val find_name : string -> 'a tbl -> t * 'a val find_all : string -> 'a tbl -> (t * 'a ) listval fold_name : (t -> 'a -> 'b -> 'b ) -> 'a tbl -> 'b -> 'b val fold_all : (t -> 'a -> 'b -> 'b ) -> 'a tbl -> 'b -> 'b val iter : (t -> 'a -> -> 'a tbl -> val make_key_generator : unit -> t -> t Binutils (ocaml.Binutils) Up – ocaml » Binutilstype error = | Truncated_file | Unrecognized of string| Unsupported of string * int64| Out_of_range of stringval error_to_string : error -> val defines_symbol : t -> string -> boolval symbol_offset : t -> string -> int64 option Cond_branch (ocaml.Branch_relaxation.Make.T.Cond_branch) Up – ocaml » Branch_relaxation » Make » T » Cond_branchT (ocaml.Branch_relaxation.Make.T) Up – ocaml » Branch_relaxation » Make » TMake (ocaml.Branch_relaxation.Make) Up – ocaml » Branch_relaxation » MakeModule Branch_relaxation.Make Branch_relaxation (ocaml.Branch_relaxation) Up – ocaml » Branch_relaxationBranch_relaxation_intf (ocaml.Branch_relaxation_intf) Up – ocaml » Branch_relaxation_intfModule Branch_relaxation_intf module type S = sig ... end Cond_branch (ocaml.Branch_relaxation_intf.S.Cond_branch) Up – ocaml » Branch_relaxation_intf » S » Cond_branchS (ocaml.Branch_relaxation_intf.S) Up – ocaml » Branch_relaxation_intf » SModule type Branch_relaxation_intf.S For_copy (ocaml.Btype.For_copy) Up – ocaml » Btype » For_copyTransientTypeMap (ocaml.Btype.TransientTypeMap) Up – ocaml » Btype » TransientTypeMapModule Btype.TransientTypeMap The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
TypeHash (ocaml.Btype.TypeHash) Up – ocaml » Btype » TypeHashinclude Hashtbl.S with type key = Types.transient_expr val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc TypeMap (ocaml.Btype.TypeMap) Up – ocaml » Btype » TypeMapinclude Map.S
+ with type key = Types.transient_expr and type 'a t = 'a TransientTypeMap.t The type of the map keys.
The type of maps from type key to type 'a.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
TypePairs (ocaml.Btype.TypePairs) Up – ocaml » Btype » TypePairsTypeSet (ocaml.Btype.TypeSet) Up – ocaml » Btype » TypeSetinclude Set.S with type elt = Types.transient_expr The type of the set elements.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Btype (ocaml.Btype) Up – ocaml » Btypeval is_row_name : string -> boolval cleanup_abbrev : unit -> unit
Build_export_info (ocaml.Build_export_info) Up – ocaml » Build_export_infoBuild_path_prefix_map (ocaml.Build_path_prefix_map) Up – ocaml » Build_path_prefix_mapModule Build_path_prefix_map Rewrite paths for reproducible builds
Warning: this module is unstable and part of compiler-libs .
See the BUILD_PATH_PREFIX_MAP spec
type path_prefix = string type error_message = string val encode_pair : pair -> type map = pair option val encode_map : map -> rewrite_first 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.
rewrite_all map path finds all sources in map that are a prefix of the input path. For each matching source, in priority order, it replaces this prefix with the corresponding target and adds the result to the returned list. If there are no matches, it just returns [].
rewrite path uses rewrite_first to try to find a mapping for path. If found, it returns that, otherwise it just returns path.
Builtin_attributes (ocaml.Builtin_attributes) Up – ocaml » Builtin_attributesModule Builtin_attributes Support for some of the builtin attributes
ocaml.deprecated ocaml.alert ocaml.error ocaml.ppwarning ocaml.warning ocaml.warnerror ocaml.explicit_arity (for camlp4/camlp5) ocaml.warn_on_literal_pattern ocaml.deprecated_mutable ocaml.immediate ocaml.immediate64 ocaml.boxed / ocaml.unboxed Warning: this module is unstable and part of compiler-libs .
Apply 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).
Execute 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.
Bytegen (ocaml.Bytegen) Up – ocaml » BytegenBytelibrarian (ocaml.Bytelibrarian) Up – ocaml » Bytelibrarianval create_archive : string list -> string -> unittype error = | File_not_found of string| Not_an_object_file of stringDep (ocaml.Bytelink.Dep) Up – ocaml » Bytelink » DepThe type of the set elements.
val compare : t -> t -> 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.
DepSet (ocaml.Bytelink.DepSet) Up – ocaml » Bytelink » DepSetThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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, but returns the largest element of the given set.
val max_elt_opt : t -> elt optionSame 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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Bytelink (ocaml.Bytelink) Up – ocaml » BytelinkBytepackager (ocaml.Bytepackager) Up – ocaml » Bytepackagertype error = | Forward_reference of string * Ident.t | Multiple_definition of string * Ident.t | Not_an_object_file of string| Illegal_renaming of string * string * string| File_not_found of stringName (ocaml.Bytesections.Name) Up – ocaml » Bytesections » Nametype raw_name = private string type t = | CODE | CRCS | DATA | DBUG | DLLS | DLPT | PRIM | RNTM The path to the bytecode interpreter (use_runtime mode)
| SYMB | Other of raw_name val of_string : string -> t val to_string : t -> Bytesections (ocaml.Bytesections) Up – ocaml » Bytesectionsmodule Name : sig ... end Recording sections written to a bytecode executable file
Start recording sections from the current position in out_channel
Record the current position in the out_channel as the end of the section with the given name.
Write the table of contents and the standard trailer for bytecode executable files
Reading sections from a bytecode executable file
type section_entry = { name : Name.t ; pos : int; byte offset at which the section starts.
len : int; } exception Bad_magic_number Read the table of sections from a bytecode executable. Raise Bad_magic_number if magic number doesn't match
Position the input channel at the beginning of the section named "name", and return the length of that section. Raise Not_found if no such section exists.
Return the contents of a section, as a string.
Return the contents of a section, as marshalled data.
Returns all section_entry from a section_table in increasing position order.
Return the position of the beginning of the first section
CSE (ocaml.CSE) Up – ocaml » CSEcse_generic (ocaml.CSEgen.cse_generic) Up – ocaml » CSEgen » cse_genericCSEgen (ocaml.CSEgen) Up – ocaml » CSEgenCamlinternalFormat (ocaml.CamlinternalFormat) Up – ocaml » CamlinternalFormatModule CamlinternalFormat type mutable_char_set = bytes and ('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 | Acc_char_literal of ('b , 'c ) acc | Acc_data_string of ('b , 'c ) acc | Acc_data_char of ('b , 'c ) acc | Acc_delay of ('b , 'c ) acc 'b -> 'c | Acc_flush of ('b , 'c ) acc | Acc_invalid_arg of ('b , 'c ) acc | End_of_acc type ('b, 'c, 'e, 'f) fmt_ebb = | Fmt_EBB : ('a , 'b , 'c , 'd , 'e , 'f ) CamlinternalFormatBasics.fmt -> ('b ,
+ 'c ,
+ 'e ,
+ 'f )
+ fmt_ebb val fmt_ebb_of_string :
+ ?legacy_behavior :bool -> string ->
+ ('b , 'c , 'e , 'f ) fmt_ebb val 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_rel val 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_rel val 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.fmt CamlinternalFormatBasics (ocaml.CamlinternalFormatBasics) Up – ocaml » CamlinternalFormatBasicsModule CamlinternalFormatBasics type padty = | Left | Right | Zeros type int_conv = | Int_d | Int_pd | Int_sd | Int_i | Int_pi | Int_si | Int_x | Int_Cx | Int_X | Int_CX | Int_o | Int_Co | Int_u | Int_Cd | Int_Ci | Int_Cu type float_flag_conv = | Float_flag_ | Float_flag_p | Float_flag_s type float_kind_conv = | Float_f | Float_e | Float_E | Float_g | Float_G | Float_F | Float_h | Float_H | Float_CF type counter = | Line_counter | Char_counter | Token_counter type pad_option = int option type ('a, 'b) precision = | No_precision : ('a , 'a ) precision | Lit_precision : int -> ('a , 'a ) precision | Arg_precision : (int -> 'a , 'a ) precision type prec_option = int option type block_type = | Pp_hbox | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits and ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
+ ('a , 'b , 'c , 'd , 'e , 'f , 'a , 'b , 'c , 'd , 'e , 'f ) fmtty_rel and ('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_rel and ('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 ) fmt 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 ) ignored val concat_fmtty :
+ ('g1 , 'b1 , 'c1 , 'j1 , 'd1 , 'a1 , 'g2 , 'b2 , 'c2 , 'j2 , 'd2 , 'a2 ) fmtty_rel -> ('a1 , 'b1 , 'c1 , 'd1 , 'e1 , 'f1 , 'a2 , 'b2 , 'c2 , 'd2 , 'e2 , 'f2 ) fmtty_rel -> ('g1 , 'b1 , 'c1 , 'j1 , 'e1 , 'f1 , 'g2 , 'b2 , 'c2 , 'j2 , 'e2 , 'f2 ) fmtty_rel val erase_rel :
+ ('a , 'b , 'c , 'd , 'e , 'f , 'g , 'h , 'i , 'j , 'k , 'l ) fmtty_rel -> ('a , 'b , 'c , 'd , 'e , 'f ) fmtty val concat_fmt :
+ ('a , 'b , 'c , 'd , 'e , 'f ) fmt -> ('f , 'b , 'c , 'e , 'g , 'h ) fmt -> ('a , 'b , 'c , 'd , 'g , 'h ) fmt CamlinternalLazy (ocaml.CamlinternalLazy) Up – ocaml » CamlinternalLazyval force_lazy_block : 'a lazy_t-> 'a val force_gen : only_val :bool -> 'a lazy_t-> 'a Simplified (ocaml.CamlinternalMenhirLib.Convert.Simplified) Up – ocaml » CamlinternalMenhirLib » Convert » SimplifiedModule Convert.Simplified Convert (ocaml.CamlinternalMenhirLib.Convert) Up – ocaml » CamlinternalMenhirLib » ConvertModule CamlinternalMenhirLib.Convert type ('token, 'semantic_value) revised = (unit -> 'token ) -> 'semantic_value Log (ocaml.CamlinternalMenhirLib.Engine.Make.T.Log) Up – ocaml » CamlinternalMenhirLib » Engine » Make » T » Logval state : state -> val initiating_error_handling : unit -> unitval resuming_error_handling : unit -> unitval handling_error : state -> T (ocaml.CamlinternalMenhirLib.Engine.Make.T) Up – ocaml » CamlinternalMenhirLib » Engine » Make » Tval number : state -> val foreach_terminal : (terminal -> 'a -> 'a ) -> 'a -> 'a val default_reduction :
+ state -> ('env -> production -> 'answer ) -> ('env -> 'answer ) -> 'env -> 'answer Make (ocaml.CamlinternalMenhirLib.Engine.Make) Up – ocaml » CamlinternalMenhirLib » Engine » MakeEngine (ocaml.CamlinternalMenhirLib.Engine) Up – ocaml » CamlinternalMenhirLib » EngineModule CamlinternalMenhirLib.Engine EngineTypes (ocaml.CamlinternalMenhirLib.EngineTypes) Up – ocaml » CamlinternalMenhirLib » EngineTypesModule CamlinternalMenhirLib.EngineTypes module type TABLE = sig ... end module type ENGINE = sig ... end ENGINE (ocaml.CamlinternalMenhirLib.EngineTypes.ENGINE) Up – ocaml » CamlinternalMenhirLib » EngineTypes » ENGINEModule type EngineTypes.ENGINE INCREMENTAL_ENGINE_START (ocaml.CamlinternalMenhirLib.EngineTypes.INCREMENTAL_ENGINE_START) Up – ocaml » CamlinternalMenhirLib » EngineTypes » INCREMENTAL_ENGINE_STARTModule type EngineTypes.INCREMENTAL_ENGINE_START MONOLITHIC_ENGINE (ocaml.CamlinternalMenhirLib.EngineTypes.MONOLITHIC_ENGINE) Up – ocaml » CamlinternalMenhirLib » EngineTypes » MONOLITHIC_ENGINEModule type EngineTypes.MONOLITHIC_ENGINE Log (ocaml.CamlinternalMenhirLib.EngineTypes.TABLE.Log) Up – ocaml » CamlinternalMenhirLib » EngineTypes » TABLE » Logval state : state -> val initiating_error_handling : unit -> unitval resuming_error_handling : unit -> unitval handling_error : state -> TABLE (ocaml.CamlinternalMenhirLib.EngineTypes.TABLE) Up – ocaml » CamlinternalMenhirLib » EngineTypes » TABLEModule type EngineTypes.TABLE val number : state -> val foreach_terminal : (terminal -> 'a -> 'a ) -> 'a -> 'a val default_reduction :
+ state -> ('env -> production -> 'answer ) -> ('env -> 'answer ) -> 'env -> 'answer ErrorReports (ocaml.CamlinternalMenhirLib.ErrorReports) Up – ocaml » CamlinternalMenhirLib » ErrorReportsModule CamlinternalMenhirLib.ErrorReports val show : ('a -> -> 'a buffer ->
val sanitize : string -> stringval compress : string -> stringval shorten : int -> string -> stringval expand : (int -> string) -> string -> stringGeneral (ocaml.CamlinternalMenhirLib.General) Up – ocaml » CamlinternalMenhirLib » GeneralModule CamlinternalMenhirLib.General val take : int -> 'a list-> 'a listval drop : int -> 'a list-> 'a listval uniq : ('a -> 'a -> -> 'a list-> 'a listval weed : ('a -> 'a -> -> 'a list-> 'a listand 'a head = | Nil | Cons of 'a * 'a stream val foldr : ('a -> 'b -> 'b ) -> 'a stream -> 'b -> 'b IncrementalEngine (ocaml.CamlinternalMenhirLib.IncrementalEngine) Up – ocaml » CamlinternalMenhirLib » IncrementalEngineModule CamlinternalMenhirLib.IncrementalEngine EVERYTHING (ocaml.CamlinternalMenhirLib.IncrementalEngine.EVERYTHING) Up – ocaml » CamlinternalMenhirLib » IncrementalEngine » EVERYTHINGModule type IncrementalEngine.EVERYTHING include INCREMENTAL_ENGINE type 'a checkpoint = private | InputNeeded of 'a env | Shifting of 'a env 'a env | AboutToReduce of 'a env production | HandlingError of 'a env | Accepted of 'a | Rejected type strategy = [ | `Legacy | `Simplified ] val pop_many : int -> 'a env -> 'a env val current_state_number : 'a env -> val equal : 'a env -> 'a env -> val env_has_default_reduction : 'a env -> val state_has_default_reduction : _ lr1state -> val pop : 'a env -> 'a env INCREMENTAL_ENGINE (ocaml.CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE) Up – ocaml » CamlinternalMenhirLib » IncrementalEngine » INCREMENTAL_ENGINEModule type IncrementalEngine.INCREMENTAL_ENGINE type 'a checkpoint = private | InputNeeded of 'a env | Shifting of 'a env 'a env | AboutToReduce of 'a env production | HandlingError of 'a env | Accepted of 'a | Rejected type strategy = [ | `Legacy | `Simplified ] val pop_many : int -> 'a env -> 'a env val current_state_number : 'a env -> val equal : 'a env -> 'a env -> val env_has_default_reduction : 'a env -> val state_has_default_reduction : _ lr1state -> val pop : 'a env -> 'a env INSPECTION (ocaml.CamlinternalMenhirLib.IncrementalEngine.INSPECTION) Up – ocaml » CamlinternalMenhirLib » IncrementalEngine » INSPECTIONModule type IncrementalEngine.INSPECTION val foreach_terminal : (xsymbol -> 'a -> 'a ) -> 'a -> 'a val foreach_terminal_but_error : (xsymbol -> 'a -> 'a ) -> 'a -> 'a SYMBOLS (ocaml.CamlinternalMenhirLib.IncrementalEngine.SYMBOLS) Up – ocaml » CamlinternalMenhirLib » IncrementalEngine » SYMBOLSModule type IncrementalEngine.SYMBOLS InfiniteArray (ocaml.CamlinternalMenhirLib.InfiniteArray) Up – ocaml » CamlinternalMenhirLib » InfiniteArrayModule CamlinternalMenhirLib.InfiniteArray This module implements infinite arrays. *
make x creates an infinite array, where every slot contains x. *
val get : 'a t -> int -> 'a get 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 -> set a i x sets the element contained at offset i in the array a to x. Slots are numbered 0 and up. *
extent 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.
InspectionTableFormat (ocaml.CamlinternalMenhirLib.InspectionTableFormat) Up – ocaml » CamlinternalMenhirLib » InspectionTableFormatModule CamlinternalMenhirLib.InspectionTableFormat module type TABLES = sig ... end TABLES (ocaml.CamlinternalMenhirLib.InspectionTableFormat.TABLES) Up – ocaml » CamlinternalMenhirLib » InspectionTableFormat » TABLESModule type InspectionTableFormat.TABLES TT (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Make.TT) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » Make » TTval token2terminal : token -> val trace : (string array * string array ) optionIT (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Make.IT) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » Make » ITLog (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Make.ET.Log) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » Make » ET » Logval state : state -> val initiating_error_handling : unit -> unitval resuming_error_handling : unit -> unitval handling_error : state -> ET (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Make.ET) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » Make » ETval number : state -> val foreach_terminal : (terminal -> 'a -> 'a ) -> 'a -> 'a val default_reduction :
+ state -> ('env -> production -> 'answer ) -> ('env -> 'answer ) -> 'env -> 'answer E (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Make.E) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » Make » EMake (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Make) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » MakeModule InspectionTableInterpreter.Make val compare_productions : int -> int -> intval foreach_terminal : (xsymbol -> 'a -> 'a ) -> 'a -> 'a val foreach_terminal_but_error : (xsymbol -> 'a -> 'a ) -> 'a -> 'a T (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Symbols.T) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » Symbols » TSymbols (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter.Symbols) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreter » SymbolsModule InspectionTableInterpreter.Symbols InspectionTableInterpreter (ocaml.CamlinternalMenhirLib.InspectionTableInterpreter) Up – ocaml » CamlinternalMenhirLib » InspectionTableInterpreterModule CamlinternalMenhirLib.InspectionTableInterpreter LexerUtil (ocaml.CamlinternalMenhirLib.LexerUtil) Up – ocaml » CamlinternalMenhirLib » LexerUtilModule CamlinternalMenhirLib.LexerUtil LinearizedArray (ocaml.CamlinternalMenhirLib.LinearizedArray) Up – ocaml » CamlinternalMenhirLib » LinearizedArrayModule CamlinternalMenhirLib.LinearizedArray type 'a t = 'a arrayint array val make : 'a array-> 'a t val read : 'a t -> int -> int -> 'a val write : 'a t -> int -> int -> 'a -> val row_length : 'a t -> int -> intval read_row : 'a t -> int -> 'a listval row_length_via : (int -> int) -> int -> intval read_via : (int -> 'a ) -> (int -> int) -> int -> int -> 'a val read_row_via : (int -> 'a ) -> (int -> int) -> int -> 'a listPackedIntArray (ocaml.CamlinternalMenhirLib.PackedIntArray) Up – ocaml » CamlinternalMenhirLib » PackedIntArrayModule CamlinternalMenhirLib.PackedIntArray val pack : int array -> t val get : t -> int -> intval get1 : string -> int -> intval unflatten1 : (int * string) -> int -> int -> intI (ocaml.CamlinternalMenhirLib.Printers.Make.I) Up – ocaml » CamlinternalMenhirLib » Printers » Make » Iinclude IncrementalEngine.INCREMENTAL_ENGINE type 'a checkpoint = private | InputNeeded of 'a env | Shifting of 'a env 'a env | AboutToReduce of 'a env production | HandlingError of 'a env | Accepted of 'a | Rejected type strategy = [ | `Legacy | `Simplified ] val pop_many : int -> 'a env -> 'a env val current_state_number : 'a env -> val equal : 'a env -> 'a env -> val env_has_default_reduction : 'a env -> val state_has_default_reduction : _ lr1state -> val pop : 'a env -> 'a env User (ocaml.CamlinternalMenhirLib.Printers.Make.User) Up – ocaml » CamlinternalMenhirLib » Printers » Make » Userval print : string -> unitval print_element : (I.element -> optionMake (ocaml.CamlinternalMenhirLib.Printers.Make) Up – ocaml » CamlinternalMenhirLib » Printers » Makemodule User : sig ... end val print_element_as_symbol : I.element -> val print_stack : 'a I.env -> val print_item : I.item -> val print_current_state : 'a I.env -> val print_env : 'a I.env -> Printers (ocaml.CamlinternalMenhirLib.Printers) Up – ocaml » CamlinternalMenhirLib » PrintersModule CamlinternalMenhirLib.Printers RowDisplacement (ocaml.CamlinternalMenhirLib.RowDisplacement) Up – ocaml » CamlinternalMenhirLib » RowDisplacementModule CamlinternalMenhirLib.RowDisplacement type 'a table = int array * 'a array val compress :
+ ('a -> 'a -> -> ('a -> -> 'a -> int ->
+ int ->
+ 'a array-> 'a table val get : 'a table -> int -> int -> 'a val getget :
+ ('displacement -> int -> int) -> ('data -> int -> 'a ) -> ('displacement * 'data ) -> int ->
+ int ->
+ 'a StaticVersion (ocaml.CamlinternalMenhirLib.StaticVersion) Up – ocaml » CamlinternalMenhirLib » StaticVersionModule CamlinternalMenhirLib.StaticVersion val require_20210419 : unitTableFormat (ocaml.CamlinternalMenhirLib.TableFormat) Up – ocaml » CamlinternalMenhirLib » TableFormatModule CamlinternalMenhirLib.TableFormat module type TABLES = sig ... end TABLES (ocaml.CamlinternalMenhirLib.TableFormat.TABLES) Up – ocaml » CamlinternalMenhirLib » TableFormat » TABLESModule type TableFormat.TABLES val token2terminal : token -> val trace : (string array * string array ) optionLog (ocaml.CamlinternalMenhirLib.TableInterpreter.MakeEngineTable.Log) Up – ocaml » CamlinternalMenhirLib » TableInterpreter » MakeEngineTable » LogModule MakeEngineTable.Log val state : state -> val initiating_error_handling : unit -> unitval resuming_error_handling : unit -> unitval handling_error : state -> T (ocaml.CamlinternalMenhirLib.TableInterpreter.MakeEngineTable.T) Up – ocaml » CamlinternalMenhirLib » TableInterpreter » MakeEngineTable » TParameter MakeEngineTable.T val token2terminal : token -> val trace : (string array * string array ) optionMakeEngineTable (ocaml.CamlinternalMenhirLib.TableInterpreter.MakeEngineTable) Up – ocaml » CamlinternalMenhirLib » TableInterpreter » MakeEngineTableModule TableInterpreter.MakeEngineTable val number : state -> val foreach_terminal : (terminal -> 'a -> 'a ) -> 'a -> 'a val default_reduction :
+ state -> ('env -> production -> 'answer ) -> ('env -> 'answer ) -> 'env -> 'answer TableInterpreter (ocaml.CamlinternalMenhirLib.TableInterpreter) Up – ocaml » CamlinternalMenhirLib » TableInterpreterModule CamlinternalMenhirLib.TableInterpreter CamlinternalMenhirLib (ocaml.CamlinternalMenhirLib) Up – ocaml » CamlinternalMenhirLibModule CamlinternalMenhirLib CamlinternalMod (ocaml.CamlinternalMod) Up – ocaml » CamlinternalModCamlinternalOO (ocaml.CamlinternalOO) Up – ocaml » CamlinternalOOval public_method_label : string -> tag val new_variable : table -> string -> intval new_methods_variables :
+ table -> string array -> string array -> label arrayval get_variable : table -> string -> intval get_variables : table -> string array -> int array val get_method_labels : table -> string array -> label arrayval narrow : table -> string array -> string array -> string array -> val widen : table -> val add_initializer : table -> (obj -> -> val create_table : string array -> table val init_class : table -> val copy : < .. > as 'a -> 'a val run_initializers : obj -> table -> val create_object_and_run_initializers : obj -> table -> obj val sendcache : obj -> tag -> t -> int -> t type 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 closure type params = { mutable compact_table : bool;mutable copy_parent : bool;mutable clean_when_copying : bool;mutable retry_count : int;mutable bucket_small_size : int;} type stats = { classes : int; methods : int; inst_vars : int; } val stats : unit -> stats Ccomp (ocaml.Ccomp) Up – ocaml » CcompModule Ccomp Compiling C files and building C libraries
Warning: this module is unstable and part of compiler-libs .
val command : string -> intval run_command : string -> unitval compile_file :
+ ?output :string -> ?opt :string -> ?stable_name :string -> string ->
+ intval create_archive : string -> string list -> val quote_files : response_files :bool -> string list -> val quote_optfile : string option -> type link_mode = | Exe | Dll | MainDll | Partial val call_linker : link_mode -> string -> string list -> string -> intval linker_is_flexlink : boolClambda (ocaml.Clambda) Up – ocaml » Clambdatype function_label = string type ustructured_constant = | Uconst_float of float| Uconst_int32 of int32| Uconst_int64 of int64| Uconst_nativeint of nativeint| Uconst_block of int * uconstant list| Uconst_float_array of float list | Uconst_string of string| Uconst_closure of ufunction listuconstant listand uphantom_defining_expr = | Uphantom_const of uconstant The phantom-let-bound variable is a constant.
| Uphantom_var of Backend_var.t The 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 { sym : string; field : int; } 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_switch = { us_index_consts : int array ; us_actions_consts : ulambda array us_index_blocks : int array ; us_actions_blocks : ulambda array } type usymbol_provenance = { original_idents : Ident.t list module_path : Path.t ; } type uconstant_block_field = | Uconst_field_ref of string| Uconst_field_int of intClambda_primitives (ocaml.Clambda_primitives) Up – ocaml » Clambda_primitivesModule Clambda_primitives type boxed = | Boxed | Unboxed type memory_access_size = | Sixteen | Thirty_two | Sixty_four and bigarray_kind = Lambda.bigarray_kind = | Pbigarray_unknown | Pbigarray_float32 | Pbigarray_float64 | Pbigarray_sint8 | Pbigarray_uint8 | Pbigarray_sint16 | Pbigarray_uint16 | Pbigarray_int32 | Pbigarray_int64 | Pbigarray_caml_int | Pbigarray_native_int | Pbigarray_complex32 | Pbigarray_complex64 and bigarray_layout = Lambda.bigarray_layout = | Pbigarray_unknown_layout | Pbigarray_c_layout | Pbigarray_fortran_layout Compiler_pass (ocaml.Clflags.Compiler_pass) Up – ocaml » Clflags » Compiler_passModule Clflags.Compiler_pass type t = | Parsing | Typing | Lambda | Scheduling | Emit val of_string : string -> t optionval to_string : t -> val is_compilation_pass : t -> val available_pass_names : filter :(t -> -> native :bool -> string list val can_save_ir_after : t -> val compare : t -> t -> val to_output_filename : t -> prefix :string -> Float_arg_helper (ocaml.Clflags.Float_arg_helper) Up – ocaml » Clflags » Float_arg_helperval parse : string -> string -> parsed ref -> type parse_result = | Ok | Parse_failed of exnval get : key :int -> parsed -> Int_arg_helper (ocaml.Clflags.Int_arg_helper) Up – ocaml » Clflags » Int_arg_helperval parse : string -> string -> parsed ref -> type parse_result = | Ok | Parse_failed of exnval get : key :int -> parsed -> Clflags (ocaml.Clflags) Up – ocaml » ClflagsModule Clflags Command line flags
Optimization parameters represented as ints indexed by round number.
Optimization 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 ; } Set all the inlining arguments for a round. The default is set if no round is provided.
val objfiles : string list ref val ccobjs : string list ref val dllibs : string list ref val cmi_file : string option ref val compile_only : bool ref val output_name : string option ref val include_dirs : string list ref val no_std_include : bool ref val print_types : bool ref val make_archive : bool ref val debug_full : bool ref val use_linscan : bool ref val link_everything : bool ref val custom_runtime : bool ref val no_check_prims : bool ref val bytecode_compatible_32 : bool ref val output_c_object : bool ref val output_complete_object : bool ref val output_complete_executable : bool ref val all_ccopts : string list ref val nopervasives : bool ref val match_context_rows : int ref val safer_matching : bool ref val open_modules : string list ref val preprocessor : string option ref val all_ppx : string list ref val annotations : bool ref val binary_annotations : bool ref val use_threads : bool ref val nopromptcont : bool ref val init_file : string option ref val use_prims : string ref val use_runtime : string ref val real_paths : bool ref val recursive_types : bool ref val strict_sequence : bool ref val applicative_functors : bool ref val make_runtime : bool ref val c_compiler : string option ref val no_auto_link : bool ref val dllpaths : string list ref val make_package : bool ref val for_package : string option ref val float_const_prop : bool ref val transparent_modules : bool ref val unique_ids : bool ref val dump_source : bool ref val dump_parsetree : bool ref val dump_typedtree : bool ref val dump_shape : bool ref val dump_rawlambda : bool ref val dump_lambda : bool ref val dump_rawclambda : bool ref val dump_clambda : bool ref val dump_rawflambda : bool ref val dump_flambda : bool ref val dump_flambda_let : int option ref val dump_instr : bool ref val keep_camlprimc_file : bool ref val keep_asm_file : bool ref val optimize_for_speed : bool ref val dump_selection : bool ref val dump_spill : bool ref val dump_split : bool ref val dump_interf : bool ref val dump_prefer : bool ref val dump_regalloc : bool ref val dump_reload : bool ref val dump_scheduling : bool ref val dump_linear : bool ref val dump_interval : bool ref val keep_startup_file : bool ref val dump_combine : bool ref val native_code : bool ref val default_inline_threshold : floatval inlining_report : bool ref val simplify_rounds : int option ref val default_simplify_rounds : int ref val default_inline_max_unroll : intval default_inline_toplevel_threshold : intval default_inline_call_cost : intval default_inline_alloc_cost : intval default_inline_prim_cost : intval default_inline_branch_cost : intval default_inline_indirect_cost : intval default_inline_lifting_benefit : intval default_inline_branch_factor : floatval dont_write_files : bool ref val std_include_flag : string -> stringval std_include_dir : unit -> string list val runtime_variant : string ref val with_runtime : bool ref val force_slash : bool ref val flambda_invariant_checks : bool ref val unbox_closures : bool ref val unbox_closures_factor : int ref val default_unbox_closures_factor : intval unbox_free_vars_of_closures : bool ref val unbox_specialised_args : bool ref val clambda_checks : bool ref val cmm_invariants : bool ref val default_inline_max_depth : intval remove_unused_arguments : bool ref val dump_flambda_verbose : bool ref val classic_inlining : bool ref val afl_instrument : bool ref val afl_inst_ratio : int ref val function_sections : bool ref val all_passes : string list ref val dumped_pass : string -> boolval set_dumped_pass : string -> bool -> unitval dump_into_file : bool ref val dump_dir : string option ref type 'a env_reader = { parse : string -> 'a option print : 'a -> usage : string; env_var : string; } val unboxed_types : bool ref val insn_sched : bool ref val insn_sched_default : boolval add_arguments : string -> (string * Stdlib.Arg.spec * string) list-> val create_usage_msg : string -> stringval print_arguments : string -> unitval reset_arguments : unit -> unitClosure (ocaml.Closure) Up – ocaml » ClosureClosure_conversion (ocaml.Closure_conversion) Up – ocaml » Closure_conversionModule Closure_conversion Generation 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:
Constant blocks (by which is meant things wrapped in 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.Tuplified functions are converted to curried functions and a stub function emitted to call the curried version. For example: let rec f (x, y) = f (x + 1, y + 1) is transformed to: let rec internal_f x y = f (x + 1,y + 1) and f (x, y) = internal_f x y (* f is marked as a stub function *) The Pdirapply and Prevapply application primitives are removed and converted to normal Flambda application nodes. The lambda_to_flambda function is not re-entrant.
Env (ocaml.Closure_conversion_aux.Env) Up – ocaml » Closure_conversion_aux » EnvFunction_decl (ocaml.Closure_conversion_aux.Function_decls.Function_decl) Up – ocaml » Closure_conversion_aux » Function_decls » Function_declModule Function_decls.Function_decl val is_a_functor : t -> Function_decls (ocaml.Closure_conversion_aux.Function_decls) Up – ocaml » Closure_conversion_aux » Function_declsval closure_env_without_parameters : Env.t -> t -> Env.t Closure_conversion_aux (ocaml.Closure_conversion_aux) Up – ocaml » Closure_conversion_auxUsed to remember which Variable.t values correspond to which Ident.t values during closure conversion, and similarly for static exception identifiers.
Used 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".)
Map (ocaml.Closure_element.Map) Up – ocaml » Closure_element » MapModule Closure_element.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Closure_element.Set) Up – ocaml » Closure_element » SetModule Closure_element.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Closure_element.T) Up – ocaml » Closure_element » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Closure_element.Tbl) Up – ocaml » Closure_element » TblModule Closure_element.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Closure_element (ocaml.Closure_element) Up – ocaml » Closure_elementinclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val unique_name : t -> Map (ocaml.Closure_id.Map) Up – ocaml » Closure_id » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Closure_id.Set) Up – ocaml » Closure_id » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Closure_id.T) Up – ocaml » Closure_id » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Closure_id.Tbl) Up – ocaml » Closure_id » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Closure_id (ocaml.Closure_id) Up – ocaml » Closure_idAn 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_element include Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val unique_name : t -> Closure_middle_end (ocaml.Closure_middle_end) Up – ocaml » Closure_middle_endModule Closure_middle_end Closure_offsets (ocaml.Closure_offsets) Up – ocaml » Closure_offsetsMap (ocaml.Closure_origin.Map) Up – ocaml » Closure_origin » MapModule Closure_origin.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Closure_origin.Set) Up – ocaml » Closure_origin » SetModule Closure_origin.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Closure_origin.T) Up – ocaml » Closure_origin » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Closure_origin.Tbl) Up – ocaml » Closure_origin » TblModule Closure_origin.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Closure_origin (ocaml.Closure_origin) Up – ocaml » Closure_origininclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
Cmi_format (ocaml.Cmi_format) Up – ocaml » Cmi_formattype pers_flags = | Rectypes | Alerts of Misc.alerts | Opaque Cmm (ocaml.Cmm) Up – ocaml » Cmmtype machtype_component = | Val | Addr | Int | Float Least upper bound of two machtype_components.
Returns true iff the first supplied machtype_component is greater than or equal to the second under the relation used by lub_component.
type exttype = | XInt r OCaml value, word-sized integer
| XInt32 | XInt64 | XFloat r double-precision FP number
A variant of machtype used to describe arguments to external C functions
type float_comparison = Lambda.float_comparison = | CFeq | CFneq | CFlt | CFnlt | CFgt | CFngt | CFle | CFnle | CFge | CFnge val new_label : unit -> label val set_label : label -> val cur_label : unit -> label type rec_flag = | Nonrecursive | Recursive type phantom_defining_expr = | Cphantom_const_int of Targetint.t The 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.t The 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 { sym : string; field : int; } 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.
type memory_chunk = | Byte_unsigned | Byte_signed | Sixteen_unsigned | Sixteen_signed | Thirtytwo_unsigned | Thirtytwo_signed | Word_int | Word_val | Single | Double Every basic block should have a corresponding Debuginfo.t for its beginning.
type codegen_option = | Reduce_code_size | No_CSE type data_item = | Cdefine_symbol of string| Cglobal_symbol of string| Cint8 of int| Cint16 of int| Cint32 of nativeint| Cint of nativeint| Csingle of float| Cdouble of float| Csymbol_address of string| Cstring of string| Cskip of int| Calign of intEither 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).
Apply 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.
Apply the transformation to each immediate sub-expression.
Cmm_helpers (ocaml.Cmm_helpers) Up – ocaml » Cmm_helpersbind name arg fn is equivalent to let name = arg in fn name, or simply fn arg if arg is simple enough
Same as bind, but also treats loads from a variable as simple
Same as bind, but does not treat variables as simple
Headers
val caml_black : nativeintA null header with GC bits set to black
A constant equal to the tag for float arrays
block_header tag size creates a header with tag tag for a block of size size
Same as block_header, but with GC bits set to black
Closure headers of the given size
Infix header at the given offset
Header for a boxed float value
Header for an unboxed float array of the given size
Header for a string (or bytes) of the given length
val closure_info : arity :int -> startenv :int -> Closure info for a closure of given arity and distance to environment
Integers
Minimal/maximal OCaml integer values whose backend representation fits in a regular OCaml integer
Make an integer constant from the given integer (tags the integer)
Make a Cmm constant holding the given nativeint value. Uses Cconst_int instead of Cconst_nativeint when possible to preserve peephole optimisations.
Add an integer to the given expression
Increment/decrement of integers
Simplify the given expression knowing its last bit will be irrelevant
Simplify the given expression knowing its first bit will be irrelevant
Arithmetical operations on integers
Integer tagging. tag_int x = (x lsl 1) + 1
Integer untagging. untag_int x = (x asr 1)
Specific division operations for boxed integers
If-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
Integer and float comparison that returns int not bool
Loop construction (while true do expr done). Used to be represented as Cloop.
Convert a tagged integer into a raw integer with boolean meaning
Float boxing and unboxing
Complex number creation and access
Make the given expression return a unit value
Remove a trailing unit return if any
Blocks
Non-atomic load of a mutable field
Atomic load. All atomic fields are mutable.
field_address ptr n dbg returns an expression for the address of the nth field of the block pointed to by ptr
get_field_gen mut ptr n dbg returns an expression for the access to the nth field of the block pointed to by ptr
set_field ptr n newval init dbg returns an expression for setting the nth field of the block pointed to by ptr to newval
Same as get_header, but also clear all reserved bits of the result
Arrays
Check whether the given array is an array of regular OCaml values (as opposed to unboxed floats), from its header or pointer
Get 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 that the reserved bits are clear (see get_header_masked)
For 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.
Array 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
Strings
Objects
Lookup a method by its hash, using caml_get_public_method Arguments :
obj : the object from which to lookup tag : the hash of the method name, as a tagged integer Lookup a method by its offset in the method table Arguments :
obj : the object from which to lookup lab : the position of the required method in the object's method array, as a tagged integer Lookup and call a method using the method cache Arguments :
obj : the object from which to lookup tag : the hash of the method name, as a tagged integer cache : the method cache array pos : the position of the cache entry in the cache array args : the additional arguments to the method call Allocations
Allocate a block of regular values with the given tag
Allocate a block of unboxed floats with the given tag
Bounds checking
Generate a Ccheckbound term
check_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.
Generic application functions
val apply_function_sym : int -> stringGet the symbol for the generic application with n arguments, and ensure its presence in the set of defined symbols
val curry_function_sym : int -> stringIf 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
bigarray_get unsafe kind layout b args dbg
unsafe : if true, do not insert bound checks kind : see Lambda.bigarray_kind layout : see Lambda.bigarray_layout b : the bigarray to load from args : a list of tagged integer expressions, corresponding to the indices in the respective dimensions dbg : debugging information bigarray_set unsafe kind layout b args newval dbg Same as bigarray_get, with newval the value being assigned
Operations on 32-bit integers
low_32 _ x is a value which agrees with x on at least the low 32 bits
Sign extend from 32 bits to the word size
Zero extend from 32 bits to the word size
Boxed numbers
val caml_nativeint_ops : stringGlobal symbols for the ops field of boxed integers
val caml_int32_ops : stringval caml_int64_ops : stringBox a given integer, without sharing of constants
Unbox a given boxed integer
Used to prepare 32-bit integers on 64-bit platforms for a lsr operation
Raw memory accesses
unaligned_set size ptr idx newval dbg
unaligned_load size ptr idx dbg
Primitives
Return the n-th field of a float array (or float-only record), as an unboxed float
Unary negation of an OCaml integer
Add a constant number to an OCaml integer
Add a constant number to an OCaml integer reference
Return the length of the array argument, as an OCaml integer
Byte swap primitive Operates on Cmm integers (unboxed values)
16-bit byte swap primitive Operates on Cmm integers (untagged integers)
type assignment_kind = | Caml_modify | Caml_initialize | Simple setfield offset value_is_ptr init ptr value dbg
setfloatfield offset init ptr value dbg value is expected to be an unboxed floating point number
Operations on OCaml integers
Strings, Bytes and Bigstrings
Regular string/bytes access. Args: string/bytes, index
Load by chunk from string/bytes, bigstring. Args: string, index
Arrays
Array access. Args: array, index
Same as setfield, except the offset is one of the arguments. Args: pointer (structure/array/...), index, value
Set the byte at the given offset to the given value. Args: bytes, index, value
Set 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
Set 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
Switch
make_switch arg cases actions dbg : Generate a Cswitch construct, or optimize as a static table lookup when possible.
transl_int_switch loc arg low high cases default
transl_switch_clambda loc arg index cases
strmatch_compile dbg arg default cases
Closures and function applications
Adds a constant offset to a pointer (for infix access)
Direct application of a function via a symbol
Generic 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.
Method 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
Generate generic functions
val placeholder_fun_dbg : human_name :string -> Debuginfo.t Generate the caml_globals table
Add references to the given symbols
Generate the caml_globals_map structure, as a marshalled string constant
Generate the caml_frametable table, referencing the frametables from the given compilation units
val data_segment_table : string list -> Cmm.phrase Generate the tables for data and code positions respectively of the given compilation units
val code_segment_table : string list -> Cmm.phrase val predef_exception : int -> string -> Cmm.phrase Generate data for a predefined exception
Emit constant symbols
Produce the data_item list corresponding to a symbol definition
emit_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).
Emit specific kinds of constant blocks as data items
Cmm_invariants (ocaml.Cmm_invariants) Up – ocaml » Cmm_invariantsrun ppf fundecl analyses the given function, and returns whether any errors were encountered (with corresponding error messages printed on the given formatter).
Cmmgen (ocaml.Cmmgen) Up – ocaml » CmmgenCmmgen_state (ocaml.Cmmgen_state) Up – ocaml » Cmmgen_statetype is_global = | Global | Local val no_more_functions : unit -> boolCmo_format (ocaml.Cmo_format) Up – ocaml » Cmo_formattype reloc_info = | Reloc_literal of Stdlib.Obj.t | 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 ; } Cmt2annot (ocaml.Cmt2annot) Up – ocaml » Cmt2annotval gen_annot :
+ string option -> sourcefile :string option -> use_summaries :bool -> Cmt_format.binary_annots -> Cmt_format (ocaml.Cmt_format) Up – ocaml » Cmt_formatThe 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:
a cmti, or a cmt, for a ml file which has no corresponding mli (hence no corresponding cmti). 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 error = | Not_a_typedtree of stringread 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.
save_cmt filename modname binary_annots sourcefile initial_env cmi writes a cmt(i) file.
Cmx_format (ocaml.Cmx_format) Up – ocaml » Cmx_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;mutable ui_for_pack : string option ;} Cmxs_format (ocaml.Cmxs_format) Up – ocaml » Cmxs_formatColoring (ocaml.Coloring) Up – ocaml » Coloringval allocate_registers : unit -> int array Comballoc (ocaml.Comballoc) Up – ocaml » ComballocCompenv (ocaml.Compenv) Up – ocaml » Compenvexception Exit_with_status of intval module_of_filename : string -> string -> stringval output_prefix : string -> string
val default_output : string option -> val print_version_and_library : string -> 'a val print_version_string : unit -> 'a val print_standard_library : unit -> 'a val first_ccopts : string list ref val first_ppx : string list ref val first_include_dirs : string list ref val last_include_dirs : string list ref val get_objfiles : with_ocamlparam :bool -> string list val last_objfiles : string list ref val first_objfiles : string list ref val stop_early : bool ref type readenv_position = | Before_args | Before_compile of filename | Before_link val is_unit_name : string -> boolval check_unit_name : string -> string -> unittype deferred_action = | ProcessImplementation of string| ProcessInterface of string| ProcessCFile of string| ProcessOtherFile of string| ProcessObjects of string list | ProcessDLLs of string list val c_object_of_filename : string -> stringval anonymous : string -> unitval impl : string -> unitval intf : string -> unitval process_deferred_actions :
+ (Stdlib.Format.formatter
+ * (start_from :Clflags.Compiler_pass.t -> source_file :string -> output_prefix :string ->
+ * (source_file :string -> output_prefix :string ->
+ * string
+ * string) -> Map (ocaml.Compilation_unit.Map) Up – ocaml » Compilation_unit » MapModule Compilation_unit.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Compilation_unit.Set) Up – ocaml » Compilation_unit » SetModule Compilation_unit.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Compilation_unit.T) Up – ocaml » Compilation_unit » TModule Compilation_unit.T include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Compilation_unit.Tbl) Up – ocaml » Compilation_unit » TblModule Compilation_unit.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Compilation_unit (ocaml.Compilation_unit) Up – ocaml » Compilation_unitinclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val is_current : t -> val set_current : t -> val get_current : unit -> t optionval get_current_exn : unit -> t val get_current_id_exn : unit -> Ident.t val string_for_printing : t -> Compile (ocaml.Compile) Up – ocaml » Compileval interface : source_file :string -> output_prefix :string -> val implementation :
+ start_from :Clflags.Compiler_pass.t -> source_file :string -> output_prefix :string -> *
to_bytecode info typed takes a typechecked implementation and returns its bytecode.
emit_bytecode bytecode output the bytecode executable.
Compile_common (ocaml.Compile_common) Up – ocaml » Compile_commontype 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 ) -> 'a with_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.
parse_intf info parses an interface (usually an .mli file).
typecheck_intf info parsetree typechecks an interface and returns the typedtree of the associated signature.
emit_signature info parsetree typedtree emits the .cmi file containing the given signature.
val interface : info -> The complete compilation pipeline for interfaces.
parse_impl info parses an implementation (usually an .ml file).
typecheck_impl info parsetree typechecks an implementation and returns the typedtree of the associated module, its public interface, and a coercion against that public interface.
The complete compilation pipeline for implementations.
val annot : info -> Return the filename of some compiler build artifacts associated with the file being compiled.
Compilenv (ocaml.Compilenv) Up – ocaml » Compilenvval reset : ?packname :string -> string -> unitval unit_id_from_name : string -> Ident.t val current_unit_name : unit -> stringval current_unit_symbol : unit -> Symbol.t val make_symbol : ?unitname :string -> string option -> val symbol_in_current_unit : string -> boolval is_predefined_exception : Symbol.t -> val symbol_for_global : Ident.t -> val record_global_approx_toplevel : unit -> unitval need_curry_fun : int -> unitval need_apply_fun : int -> unitval need_send_fun : int -> unitval new_const_symbol : unit -> stringval clear_structured_constants : unit -> unitval add_exported_constant : string -> unittype structured_constantsval save_unit_info : string -> unitval require_global : Ident.t -> type error = | Not_a_unit_info of string| Corrupted_unit_info of string| Illegal_renaming of string * string * string| Mismatching_for_pack of string * string * string * string option Compmisc (ocaml.Compmisc) Up – ocaml » Compmiscval initial_env : unit -> Env.t val read_clflags_from_env : unit -> unitauto_include find_in_dir fn is a callback function to be passed to Load_path.init-I +lib to the load path after displaying an alert.
Compression (ocaml.Compression) Up – ocaml » CompressionCompression.output_value chan v writes the representation of v on channel chan. If compression is supported, the marshaled data representing value v is compressed before being written to channel chan. If compression is not supported, this function behaves like Stdlib.output_value
Compression.input_value chan reads from channel chan the byte representation of a structured value, as produced by Compression.output_value, and reconstructs and returns the corresponding value. If compression is not supported, this function behaves like Stdlib.input_value
val compression_supported : boolReports whether compression is supported.
Config (ocaml.Config) Up – ocaml » ConfigThe current version number of the system
The directory containing the binary programs
val standard_library : stringThe directory containing the standard libraries
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 compiler to use for compiling C files
val c_output_obj : stringName of the option of the C compiler for specifying the output file
val c_has_debug_prefix_map : boolWhether the C compiler supports -fdebug-prefix-map
val as_has_debug_prefix_map : boolWhether the assembler supports --debug-prefix-map
val ocamlc_cflags : stringThe flags ocamlc should pass to the C compiler
val ocamlc_cppflags : stringThe flags ocamlc should pass to the C preprocessor
val ocamlopt_cflags : stringval ocamlopt_cppflags : stringval bytecomp_c_libraries : stringThe C libraries to link with custom runtimes
val native_c_libraries : stringThe C libraries to link with native-code programs
val native_pack_linker : stringThe linker to use for packaging (ocamlopt -pack) and for partial links (ocamlopt -output-obj).
The linker command line to build dynamic libraries.
The linker command line to build executables.
The linker command line to build main programs as dlls.
val default_rpath : stringOption to add a directory to be searched for libraries at runtime (used by ocamlmklib)
val mksharedlibrpath : stringOption to add a directory to be searched for shared libraries at runtime (used by ocamlmklib)
Name of the ar command, or "" if not needed (MSVC)
val interface_suffix : string ref Suffix for interface file names
val exec_magic_number : stringMagic number for bytecode executable files
val cmi_magic_number : stringMagic number for compiled interface files
val cmo_magic_number : stringMagic number for object bytecode files
val cma_magic_number : stringMagic number for archive files
val cmx_magic_number : stringMagic number for compilation unit descriptions
val cmxa_magic_number : stringMagic number for libraries of compilation unit descriptions
val ast_intf_magic_number : stringMagic number for file holding an interface syntax tree
val ast_impl_magic_number : stringMagic number for file holding an implementation syntax tree
val cmxs_magic_number : stringMagic number for dynamically-loadable plugins
val cmt_magic_number : stringMagic number for compiled interface files
val linear_magic_number : stringMagic number for Linear internal representation files
Biggest tag that can be stored in the header of a regular block.
Normally the same as Obj.lazy_tag. Separate definition because of technical reasons for bootstrapping.
val max_young_wosize : intMaximal size of arrays that are directly allocated in the minor heap
val stack_threshold : intSize in words of safe area at bottom of VM stack, see runtime/caml/config.h
val stack_safety_margin : intSize 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.
val native_compiler : boolWhether the native compiler is available or not
val architecture : stringName of processor type for the native-code compiler
Name of processor submodel for the native-code compiler
Name of operating system for the native-code compiler
The assembler (and flags) to use for assembling ocamlopt-generated code.
val asm_cfi_supported : boolWhether assembler understands CFI directives
val with_frame_pointers : boolWhether assembler should maintain frame pointers
Extension for object files, e.g. .o under Unix.
Extension for assembler files, e.g. .s under Unix.
Extension for library files, e.g. .a under Unix.
Extension for dynamically-loaded libraries, e.g. .so under Unix.
Extension for executable programs, e.g. .exe under Windows.
val default_executable_name : stringName of executable produced by linking if none is given with -o, e.g. a.out under Unix.
val systhread_supported : boolWhether the system thread library is implemented
val flexdll_dirs : string list Directories needed for the FlexDLL objects
Whether the compiler is a cross-compiler
Whether the compiler is a cross-compiler
Whether the compiler was configured for flambda
val with_flambda_invariants : boolWhether the invariants checks for flambda are enabled
val with_cmm_invariants : boolWhether the invariants checks for Cmm are enabled
How many bits of a block's header are reserved
val flat_float_array : boolWhether the compiler and runtime automagically flatten float arrays
val function_sections : boolWhether the compiler was configured to generate each function in a separate section
val windows_unicode : boolWhether Windows Unicode runtime is enabled
val naked_pointers : boolWhether the runtime supports naked pointers
val supports_shared_libraries : boolWhether shared libraries are supported
val native_dynlink : boolWhether native shared libraries are supported
val afl_instrument : boolWhether afl-fuzz instrumentation is generated by default
val ar_supports_response_files : boolWhether ar supports @FILE arguments.
Access to configuration values
val config_var : string -> string option the configuration value of a variable, if it exists
Config_boot (ocaml.Config_boot) Up – ocaml » Config_bootThe current version number of the system
The directory containing the binary programs
val standard_library : stringThe directory containing the standard libraries
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 compiler to use for compiling C files
val c_output_obj : stringName of the option of the C compiler for specifying the output file
val c_has_debug_prefix_map : boolWhether the C compiler supports -fdebug-prefix-map
val as_has_debug_prefix_map : boolWhether the assembler supports --debug-prefix-map
val ocamlc_cflags : stringThe flags ocamlc should pass to the C compiler
val ocamlc_cppflags : stringThe flags ocamlc should pass to the C preprocessor
val ocamlopt_cflags : stringval ocamlopt_cppflags : stringval bytecomp_c_libraries : stringThe C libraries to link with custom runtimes
val native_c_libraries : stringThe C libraries to link with native-code programs
val native_pack_linker : stringThe linker to use for packaging (ocamlopt -pack) and for partial links (ocamlopt -output-obj).
The linker command line to build dynamic libraries.
The linker command line to build executables.
The linker command line to build main programs as dlls.
val default_rpath : stringOption to add a directory to be searched for libraries at runtime (used by ocamlmklib)
val mksharedlibrpath : stringOption to add a directory to be searched for shared libraries at runtime (used by ocamlmklib)
Name of the ar command, or "" if not needed (MSVC)
val interface_suffix : string ref Suffix for interface file names
val exec_magic_number : stringMagic number for bytecode executable files
val cmi_magic_number : stringMagic number for compiled interface files
val cmo_magic_number : stringMagic number for object bytecode files
val cma_magic_number : stringMagic number for archive files
val cmx_magic_number : stringMagic number for compilation unit descriptions
val cmxa_magic_number : stringMagic number for libraries of compilation unit descriptions
val ast_intf_magic_number : stringMagic number for file holding an interface syntax tree
val ast_impl_magic_number : stringMagic number for file holding an implementation syntax tree
val cmxs_magic_number : stringMagic number for dynamically-loadable plugins
val cmt_magic_number : stringMagic number for compiled interface files
val linear_magic_number : stringMagic number for Linear internal representation files
Biggest tag that can be stored in the header of a regular block.
Normally the same as Obj.lazy_tag. Separate definition because of technical reasons for bootstrapping.
val max_young_wosize : intMaximal size of arrays that are directly allocated in the minor heap
val stack_threshold : intSize in words of safe area at bottom of VM stack, see runtime/caml/config.h
val stack_safety_margin : intSize 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.
val native_compiler : boolWhether the native compiler is available or not
val architecture : stringName of processor type for the native-code compiler
Name of processor submodel for the native-code compiler
Name of operating system for the native-code compiler
The assembler (and flags) to use for assembling ocamlopt-generated code.
val asm_cfi_supported : boolWhether assembler understands CFI directives
val with_frame_pointers : boolWhether assembler should maintain frame pointers
Extension for object files, e.g. .o under Unix.
Extension for assembler files, e.g. .s under Unix.
Extension for library files, e.g. .a under Unix.
Extension for dynamically-loaded libraries, e.g. .so under Unix.
Extension for executable programs, e.g. .exe under Windows.
val default_executable_name : stringName of executable produced by linking if none is given with -o, e.g. a.out under Unix.
val systhread_supported : boolWhether the system thread library is implemented
val flexdll_dirs : string list Directories needed for the FlexDLL objects
Whether the compiler is a cross-compiler
Whether the compiler is a cross-compiler
Whether the compiler was configured for flambda
val with_flambda_invariants : boolWhether the invariants checks for flambda are enabled
val with_cmm_invariants : boolWhether the invariants checks for Cmm are enabled
How many bits of a block's header are reserved
val flat_float_array : boolWhether the compiler and runtime automagically flatten float arrays
val function_sections : boolWhether the compiler was configured to generate each function in a separate section
val windows_unicode : boolWhether Windows Unicode runtime is enabled
val naked_pointers : boolWhether the runtime supports naked pointers
val supports_shared_libraries : boolWhether shared libraries are supported
val native_dynlink : boolWhether native shared libraries are supported
val afl_instrument : boolWhether afl-fuzz instrumentation is generated by default
val ar_supports_response_files : boolWhether ar supports @FILE arguments.
Access to configuration values
val config_var : string -> string option the configuration value of a variable, if it exists
Config_main (ocaml.Config_main) Up – ocaml » Config_mainThe current version number of the system
The directory containing the binary programs
val standard_library : stringThe directory containing the standard libraries
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 compiler to use for compiling C files
val c_output_obj : stringName of the option of the C compiler for specifying the output file
val c_has_debug_prefix_map : boolWhether the C compiler supports -fdebug-prefix-map
val as_has_debug_prefix_map : boolWhether the assembler supports --debug-prefix-map
val ocamlc_cflags : stringThe flags ocamlc should pass to the C compiler
val ocamlc_cppflags : stringThe flags ocamlc should pass to the C preprocessor
val ocamlopt_cflags : stringval ocamlopt_cppflags : stringval bytecomp_c_libraries : stringThe C libraries to link with custom runtimes
val native_c_libraries : stringThe C libraries to link with native-code programs
val native_pack_linker : stringThe linker to use for packaging (ocamlopt -pack) and for partial links (ocamlopt -output-obj).
The linker command line to build dynamic libraries.
The linker command line to build executables.
The linker command line to build main programs as dlls.
val default_rpath : stringOption to add a directory to be searched for libraries at runtime (used by ocamlmklib)
val mksharedlibrpath : stringOption to add a directory to be searched for shared libraries at runtime (used by ocamlmklib)
Name of the ar command, or "" if not needed (MSVC)
val interface_suffix : string ref Suffix for interface file names
val exec_magic_number : stringMagic number for bytecode executable files
val cmi_magic_number : stringMagic number for compiled interface files
val cmo_magic_number : stringMagic number for object bytecode files
val cma_magic_number : stringMagic number for archive files
val cmx_magic_number : stringMagic number for compilation unit descriptions
val cmxa_magic_number : stringMagic number for libraries of compilation unit descriptions
val ast_intf_magic_number : stringMagic number for file holding an interface syntax tree
val ast_impl_magic_number : stringMagic number for file holding an implementation syntax tree
val cmxs_magic_number : stringMagic number for dynamically-loadable plugins
val cmt_magic_number : stringMagic number for compiled interface files
val linear_magic_number : stringMagic number for Linear internal representation files
Biggest tag that can be stored in the header of a regular block.
Normally the same as Obj.lazy_tag. Separate definition because of technical reasons for bootstrapping.
val max_young_wosize : intMaximal size of arrays that are directly allocated in the minor heap
val stack_threshold : intSize in words of safe area at bottom of VM stack, see runtime/caml/config.h
val stack_safety_margin : intSize 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.
val native_compiler : boolWhether the native compiler is available or not
val architecture : stringName of processor type for the native-code compiler
Name of processor submodel for the native-code compiler
Name of operating system for the native-code compiler
The assembler (and flags) to use for assembling ocamlopt-generated code.
val asm_cfi_supported : boolWhether assembler understands CFI directives
val with_frame_pointers : boolWhether assembler should maintain frame pointers
Extension for object files, e.g. .o under Unix.
Extension for assembler files, e.g. .s under Unix.
Extension for library files, e.g. .a under Unix.
Extension for dynamically-loaded libraries, e.g. .so under Unix.
Extension for executable programs, e.g. .exe under Windows.
val default_executable_name : stringName of executable produced by linking if none is given with -o, e.g. a.out under Unix.
val systhread_supported : boolWhether the system thread library is implemented
val flexdll_dirs : string list Directories needed for the FlexDLL objects
Whether the compiler is a cross-compiler
Whether the compiler is a cross-compiler
Whether the compiler was configured for flambda
val with_flambda_invariants : boolWhether the invariants checks for flambda are enabled
val with_cmm_invariants : boolWhether the invariants checks for Cmm are enabled
How many bits of a block's header are reserved
val flat_float_array : boolWhether the compiler and runtime automagically flatten float arrays
val function_sections : boolWhether the compiler was configured to generate each function in a separate section
val windows_unicode : boolWhether Windows Unicode runtime is enabled
val naked_pointers : boolWhether the runtime supports naked pointers
val supports_shared_libraries : boolWhether shared libraries are supported
val native_dynlink : boolWhether native shared libraries are supported
val afl_instrument : boolWhether afl-fuzz instrumentation is generated by default
val ar_supports_response_files : boolWhether ar supports @FILE arguments.
Access to configuration values
val config_var : string -> string option the configuration value of a variable, if it exists
Map (ocaml.Consistbl.Make.Module_name.Map) Up – ocaml » Consistbl » Make » Module_name » MapThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Set (ocaml.Consistbl.Make.Module_name.Set) Up – ocaml » Consistbl » Make » Module_name » SetThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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, but returns the largest element of the given set.
val max_elt_opt : t -> elt optionSame 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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Tbl (ocaml.Consistbl.Make.Module_name.Tbl) Up – ocaml » Consistbl » Make » Module_name » Tblval add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> Module_name (ocaml.Consistbl.Make.Module_name) Up – ocaml » Consistbl » Make » Module_nameParameter Make.Module_name val compare : t -> t -> Make (ocaml.Consistbl.Make) Up – ocaml » Consistbl » Make
exception Inconsistency of { unit_name : Module_name.t ; inconsistent_source : string; original_source : string; } Consistbl (ocaml.Consistbl) Up – ocaml » ConsistblModule Consistbl Consistency tables: for checking consistency of module CRCs
Warning: this module is unstable and part of compiler-libs .
Convert_primitives (ocaml.Convert_primitives) Up – ocaml » Convert_primitivesModule Convert_primitives Ctype (ocaml.Ctype) Up – ocaml » Ctypeval with_local_level : ?post :('a -> -> (unit -> 'a ) -> 'a val with_local_level_if : bool -> (unit -> 'a ) -> post :('a -> -> 'a val with_local_level_iter : (unit -> 'a * 'b list -> post :('b -> -> 'a val with_local_level_iter_if :
+ bool ->
+ (unit -> 'a * 'b list -> post :('b -> -> 'a val with_level : level :int -> (unit -> 'a ) -> 'a val with_level_if : bool -> level :int -> (unit -> 'a ) -> 'a val with_local_level_if_principal : (unit -> 'a ) -> post :('a -> -> 'a val with_local_level_iter_if_principal :
+ (unit -> 'a * 'b list -> post :('b -> -> 'a val with_local_level_for_class : ?post :('a -> -> (unit -> 'a ) -> 'a val with_raised_nongen_level : (unit -> 'a ) -> 'a val reset_global_level : unit -> unitval increase_global_level : unit -> intval restore_global_level : int -> unitval create_scope : unit -> intTransform 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)
type existential_treatment = | Keep_existentials_flexible | Make_existentials_abstract of { env : Env.t ref scope : int; } The 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.
Create an Errortrace.Diff by expanding the two types
Create 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.
exception Nondep_cannot_erase of Ident.t type variable_kind = | Row_variable | Type_variable val get_current_level : unit -> intval wrap_trace_gadt_instances : Env.t -> ('a -> 'b ) -> 'a -> 'b D (ocaml.Dataflow.Backward.D) Up – ocaml » Dataflow » Backward » Dval lessequal : t -> t -> Backward (ocaml.Dataflow.Backward) Up – ocaml » Dataflow » BackwardDataflow (ocaml.Dataflow) Up – ocaml » Dataflowmodule type DOMAIN = sig ... end DOMAIN (ocaml.Dataflow.DOMAIN) Up – ocaml » Dataflow » DOMAINModule type Dataflow.DOMAIN val lessequal : t -> t -> Datarepr (ocaml.Datarepr) Up – ocaml » Datareprexception Constr_not_found Takes cd_args and cd_res from a constructor_declaration and returns:
the types of the constructor's arguments the existential variables introduced by the constructor Deadcode (ocaml.Deadcode) Up – ocaml » DeadcodeScoped_location (ocaml.Debuginfo.Scoped_location) Up – ocaml » Debuginfo » Scoped_locationModule Debuginfo.Scoped_location val string_of_scopes : scopes -> val string_of_scoped_location : t -> Debuginfo (ocaml.Debuginfo) Up – ocaml » Debuginfotype 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 alloc_dbginfo_item = { alloc_words : int; alloc_dbg : t ; } Due 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.
val to_string : t -> val compare : t -> t -> Depend (ocaml.Depend) Up – ocaml » Dependval pp_deps : string list ref dependencies found by preprocessing tools
_ (ocaml.Diffing.Define.Left_variadic._) Up – ocaml » Diffing » Define » Left_variadic » _Parameter Left_variadic._ weight 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).
update ch st returns the new state after applying a change. The update_result type also contains expansions in the variadic case.
Left_variadic (ocaml.Diffing.Define.Left_variadic) Up – ocaml » Diffing » Define » Left_variadicModule Define.Left_variadic Variadic diffing allows to expand the lists being diffed during diffing. in one specific direction.
diff state l r computes the optimal patch between l and r, using the initial state state.
_ (ocaml.Diffing.Define.Right_variadic._) Up – ocaml » Diffing » Define » Right_variadic » _Parameter Right_variadic._ weight 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).
update ch st returns the new state after applying a change. The update_result type also contains expansions in the variadic case.
Right_variadic (ocaml.Diffing.Define.Right_variadic) Up – ocaml » Diffing » Define » Right_variadicModule Define.Right_variadic diff state l r computes the optimal patch between l and r, using the initial state state.
_ (ocaml.Diffing.Define.Simple._) Up – ocaml » Diffing » Define » Simple » _weight 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).
update ch st returns the new state after applying a change. The update_result type also contains expansions in the variadic case.
Simple (ocaml.Diffing.Define.Simple) Up – ocaml » Diffing » Define » Simplediff state l r computes the optimal patch between l and r, using the initial state state.
D (ocaml.Diffing.Define.D) Up – ocaml » Diffing » Define » DDetailed difference trace
environment of a partial patch
Define (ocaml.Diffing.Define) Up – ocaml » Diffing » DefineThe type of potential changes on a list.
A patch is an ordered list of changes.
module type S = sig ... end Parameters (ocaml.Diffing.Define.Parameters) Up – ocaml » Diffing » Define » ParametersModule type Define.Parameters weight 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).
update ch st returns the new state after applying a change. The update_result type also contains expansions in the variadic case.
S (ocaml.Diffing.Define.S) Up – ocaml » Diffing » Define » Sdiff state l r computes the optimal patch between l and r, using the initial state state.
Diffing (ocaml.Diffing) Up – ocaml » DiffingModule Diffing Parametric diffing
This module implements diffing over lists of arbitrary content. It is parameterized by
The content of the two lists The equality witness when an element is kept The diffing witness when an element is changed 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.
We always return the optimal patch on prefixes of l and r on which state does not diverge. Otherwise, we return a correct but non-optimal patch where subpatches with no divergent states are optimal for the given initial state. 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 ... end The core types of a diffing implementation
type change_kind = | Deletion | Insertion | Modification | Preservation The kind of changes which is used to share printing and styling across implementation
type ('left, 'right, 'eq, 'diff) change = | Delete of 'left | Insert of 'right | Keep of 'left * 'right * 'eq | Change of 'left * 'right * 'diff Define(Defs) creates the diffing types from the types defined in Defs and the functors that need to be instantatied with the diffing algorithm parameters
Defs (ocaml.Diffing.Defs) Up – ocaml » Diffing » DefsDetailed difference trace
environment of a partial patch
_ (ocaml.Diffing_with_keys.Define.Simple._) Up – ocaml » Diffing_with_keys » Define » Simple » _val key_left : D.left -> Simple (ocaml.Diffing_with_keys.Define.Simple) Up – ocaml » Diffing_with_keys » Define » SimpleD (ocaml.Diffing_with_keys.Define.D) Up – ocaml » Diffing_with_keys » Define » DDetailed difference trace
environment of a partial patch
Define (ocaml.Diffing_with_keys.Define) Up – ocaml » Diffing_with_keys » DefineModule Diffing_with_keys.Define Composite changes and patches
Parameters (ocaml.Diffing_with_keys.Define.Parameters) Up – ocaml » Diffing_with_keys » Define » ParametersModule type Define.Parameters val key_left : D.left -> Diffing_with_keys (ocaml.Diffing_with_keys) Up – ocaml » Diffing_with_keysModule Diffing_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.
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.
type 'a with_pos = { pos : int; data : 'a ; } val with_pos : 'a list-> 'a with_pos type ('l, 'r, 'diff) mismatch = | Name of { pos : int; got : string; expected : string; types_match : bool; } | Type of { pos : int; got : 'l ; expected : 'r ; reason : 'diff ; } type ('l, 'r, 'diff) change = | Change of ('l , 'r , 'diff ) mismatch | Swap of { pos : int * int; first : string; last : string; } | Move of { name : string; got : int; expected : int; } | Insert of { pos : int; insert : 'r ; } | Delete of { pos : int; delete : 'l ; } This specialized version of changes introduces two composite changes: Move and Swap
Dll (ocaml.Dll) Up – ocaml » Dll
type dll_mode = | For_checking | For_execution val open_dlls : dll_mode -> string list -> val close_all_dlls : unit -> unittype primitive_address = | Prim_loaded of dll_address | Prim_exists val add_path : string list -> val remove_path : string list -> val init_compile : bool -> unitval init_toplevel : string list -> WithMenhir (ocaml.Docstrings.WithMenhir) Up – ocaml » Docstrings » WithMenhirModule Docstrings.WithMenhir Fetch the item documentation for the current symbol. This also marks this documentation (for ambiguity warnings).
Fetch the item documentation for the symbols between two positions. This also marks this documentation (for ambiguity warnings).
Mark 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)
Fetch the field info for the current symbol.
Fetch the field info following the symbol at a given position.
Fetch the text preceding the current symbol.
Fetch the text preceding the symbol at the given position.
There 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.
Fetch additional text preceding the current symbol
Fetch additional text following the current symbol
Fetch additional text preceding the symbol at the given position
Fetch additional text following the symbol at the given position
Fetch text following the symbol at the given position
Docstrings (ocaml.Docstrings) Up – ocaml » Docstrings(Re)Initialise all docstring state
val warn_bad_docstrings : unit -> unitEmit warnings for unattached and ambiguous docstrings
val docstring_body : docstring -> Get the text of a docstring
Get the location of a docstring
These functions are used by the lexer to associate docstrings to the locations of tokens.
Docstrings immediately preceding a token
Docstrings not immediately adjacent to a token
Docstrings immediately following the token which precedes this one
Docstrings immediately preceding the token which follows this one
The docs
Convert item documentation to attributes and add them to an attribute list
val symbol_docs : unit -> docs Fetch the item documentation for the current symbol. This also marks this documentation (for ambiguity warnings).
val rhs_docs : int -> int -> docs Fetch the item documentation for the symbols between two positions. This also marks this documentation (for ambiguity warnings).
val mark_symbol_docs : unit -> unitMark the item documentation for the current symbol (for ambiguity warnings).
val mark_rhs_docs : int -> int -> unitMark as associated the item documentation for the symbols between two positions (for ambiguity warnings)
The info
Convert field info to attributes and add them to an attribute list
val symbol_info : unit -> info Fetch the field info for the current symbol.
val rhs_info : int -> info Fetch the field info following the symbol at a given position.
The text
Convert text to attributes and add them to an attribute list
val symbol_text : unit -> text Fetch the text preceding the current symbol.
val rhs_text : int -> text Fetch the text preceding the symbol at the given position.
There 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.
Fetch additional text preceding the current symbol
Fetch additional text following the current symbol
Fetch additional text preceding the symbol at the given position
Fetch additional text following the symbol at the given position
val rhs_post_text : int -> text Fetch text following the symbol at the given position
Domainstate (ocaml.Domainstate) Up – ocaml » Domainstateval stack_ctx_words : inttype t = | Domain_young_limit | Domain_young_ptr | Domain_young_start | Domain_young_end | Domain_young_trigger | Domain_current_stack | Domain_exn_handler | Domain_action_pending | Domain_c_stack | Domain_stack_cache | Domain_gc_regs_buckets | Domain_gc_regs | Domain_minor_tables | Domain_mark_stack | Domain_marking_done | Domain_sweeping_done | Domain_allocated_words | Domain_swept_words | Domain_major_slice_epoch | Domain_local_roots | Domain_ephe_info | Domain_final_info | Domain_backtrace_pos | Domain_backtrace_active | Domain_backtrace_buffer | Domain_backtrace_last_exn | Domain_compare_unordered | Domain_oo_next_id_local | Domain_requested_major_slice | Domain_requested_global_major_slice | Domain_requested_minor_gc | Domain_requested_external_interrupt | Domain_parser_trace | Domain_minor_heap_wsz | Domain_shared_heap | Domain_id | Domain_unique_id | Domain_dls_root | Domain_extra_heap_resources | Domain_extra_heap_resources_minor | Domain_dependent_size | Domain_dependent_allocated | Domain_slice_target | Domain_slice_budget | Domain_major_work_done_between_slices | Domain_extern_state | Domain_intern_state | Domain_stat_minor_words | Domain_stat_promoted_words | Domain_stat_major_words | Domain_stat_forced_major_collections | Domain_stat_blocks_marked | Domain_inside_stw_handler | Domain_trap_sp_off | Domain_trap_barrier_off | Domain_trap_barrier_block | Domain_external_raise | Domain_extra_params val idx_of_field : t -> Dynlink (ocaml.Dynlink) Up – ocaml » Dynlinktrue if the program is native, false if the program is bytecode.
val loadfile : string -> unitIn 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
val loadfile_private : string -> unitSame 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
val adapt_filename : string -> stringIn bytecode, the identity function. In native code, replace the last extension with .cmxs.
val set_allowed_units : string list -> 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
val allow_only : string 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.
val prohibit : string list -> 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.
val main_program_units : unit -> string list Return the list of compilation units that form the main program (i.e. are not dynamically linked).
val public_dynamically_loaded_units : unit -> string list 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.
val all_units : unit -> string list 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).
val allow_unsafe_modules : bool -> unitGovern 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 linking_error = private | Undefined_global of string| Unavailable_primitive of string| Uninitialized_global of stringtype error = private | Not_a_bytecode_file of string| Inconsistent_import of string| Unavailable_unit 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 stringErrors 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 -> Convert an error description to a printable message.
Effect_analysis (ocaml.Effect_analysis) Up – ocaml » Effect_analysisConservative approximation as to whether a given Flambda expression may have any side effects.
Emit (ocaml.Emit) Up – ocaml » Emitval begin_assembly : unit -> unitval end_assembly : unit -> unitEmitaux (ocaml.Emitaux) Up – ocaml » Emitauxval emit_string : string -> unitval emit_int : int -> unitval emit_nativeint : nativeint -> unitval emit_int32 : int32 -> unitval emit_symbol : string -> unitval emit_char : char -> unitval emit_string_literal : string -> unitval emit_string_directive : string -> string -> unitval emit_bytes_directive : string -> string -> unitval emit_float64_directive : string -> int64 -> unitval emit_float64_split_directive : string -> int64 -> unitval emit_float32_directive : string -> int32 -> unitval reset_debug_info : unit -> unitval emit_debug_info_gen :
+ Debuginfo.t -> (file_num :int -> file_name :string -> -> (file_num :int -> line :int -> col :int -> -> val record_frame_descr :
+ label :int -> frame_size :int -> live_offset :int list -> frame_debuginfo -> type emit_frame_actions = { efa_code_label : int -> unit; efa_data_label : int -> unit; efa_8 : int -> unit; efa_16 : int -> unit; efa_32 : int32 -> unit; efa_word : int -> unit; efa_align : int -> unit; efa_label_rel : int -> int32 -> unit; efa_def_label : int -> unit; efa_string : string -> unit; } val is_generic_function : string -> boolval cfi_startproc : unit -> unitval cfi_endproc : unit -> unitval cfi_adjust_cfa_offset : int -> unitval cfi_offset : reg :int -> offset :int -> val cfi_def_cfa_offset : int -> unitval cfi_remember_state : unit -> unitval cfi_restore_state : unit -> unitval cfi_def_cfa_register : reg :int -> val binary_backend_available : bool ref Is 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 ref Are we actually generating the textual assembly file?
type error = | Stack_frame_too_large of inttype preproc_stack_check_result = { max_frame_size : int; contains_nontail_calls : bool; } Emitcode (ocaml.Emitcode) Up – ocaml » Emitcodeval marshal_to_channel_with_possibly_32bit_compat :
+ filename :string -> kind :string -> out_channel -> 'a -> Emitenv (ocaml.Emitenv) Up – ocaml » Emitenvtype gc_call = { gc_lbl : label ; gc_return_lbl : label ; gc_frame_lbl : label ; } type bound_error_call = { bd_lbl : label ; bd_frame : label ; } type float_literal = { fl : int64; lbl : label ; } type int_literal = { n : nativeint; n_lbl : label ; } type gotrel_literal = { lbl_got : label ; lbl_pic : label ; } type symbol_literal = { sym : string; lbl : label ; } Env (ocaml.Env) Up – ocaml » Envtype value_unbound_reason = | Val_unbound_instance_variable | Val_unbound_self | Val_unbound_ancestor | Val_unbound_ghost_recursive of Location.t type module_unbound_reason = | Mod_unbound_illegal_recursion val same_types : t -> t -> val without_cmis : ('a -> 'b ) -> 'a -> 'b val is_functor_arg : Path.t -> t -> val reset_required_globals : unit -> unitval get_required_globals : unit -> Ident.t listval add_required_global : Ident.t -> val has_local_constraints : t -> type constructor_usage = | Positive | Pattern | Exported_private | Exported type label_usage = | Projection | Mutation | Construct | Exported_private | Exported type unbound_value_hint = | No_hint | Missing_rec of Location.t val find_value_index : Ident.t -> t -> int option The find_*_index functions computes a "namespaced" De Bruijn index of an identifier in a given environment. In other words, it returns how many times an identifier has been shadowed by a more recent identifiers with the same name in a given environment. Those functions return None when the identifier is not bound in the environment. This behavior is there to facilitate the detection of inconsistent printing environment, but should disappear in the long term.
val find_type_index : Ident.t -> t -> int option val find_module_index : Ident.t -> t -> int option val find_modtype_index : Ident.t -> t -> int option val find_class_index : Ident.t -> t -> int option val find_cltype_index : Ident.t -> t -> int option val bound_value : string -> t -> val bound_module : string -> t -> val bound_type : string -> t -> val bound_modtype : string -> t -> val bound_class : string -> t -> val bound_cltype : string -> t -> val make_copy_of_types : t -> t -> t val add_persistent_structure : Ident.t -> t -> t val filter_non_loaded_persistent : (Ident.t -> -> t -> t val open_pers_signature : string -> t -> (t , [ `Not_found ] ) result val remove_last_open : Path.t -> t -> t optionval reset_cache : unit -> unitval reset_cache_toplevel : unit -> unitval set_unit_name : string -> unitval get_unit_name : unit -> stringval import_crcs : source :string -> Misc.crcs -> val keep_only_summary : t -> t val in_signature : bool -> t -> t val is_in_signature : t -> val add_delayed_check_forward : ((unit -> unit) -> ref Folds
Persistent structures are only traversed if they are already loaded.
val check_value_name : string -> Location.t -> Envaux (ocaml.Envaux) Up – ocaml » Envauxval reset_cache : unit -> unittype error = | Module_not_found of Path.t Errors (ocaml.Errors) Up – ocaml » ErrorsSubtype (ocaml.Errortrace.Subtype) Up – ocaml » Errortrace » SubtypeModule Errortrace.Subtype type 'a elt = | Diff of 'a diff Just 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.
val map : ('a -> 'b ) -> 'a t -> 'b t Errortrace (ocaml.Errortrace) Up – ocaml » Errortracetype position = | First | Second trivial_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.
type 'a diff = { got : 'a ; expected : 'a ; } val map_diff : ('a -> 'b ) -> 'a diff -> 'b diff map_diff f {expected;got} is {expected=f expected; got=f got}
Scope escape related errors
val explain : 'a list-> (prev :'a option-> 'a -> 'b option -> 'b optiontype unification = private | Unification type comparison = private | Comparison type fixed_row_case = | Cannot_be_closed | Cannot_add_tags of string list type ('a, 'variety) t = ('a , 'variety ) elt val map : ('a -> 'b ) -> ('a , 'variety ) t -> ('b , 'variety ) t val swap_trace : ('a , 'variety ) t -> ('a , 'variety ) t The 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.
Wraps up the two different kinds of comparison errors in one type
Lift swap_trace to unification_error
Event (ocaml.Event) Up – ocaml » EventModule Event First-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.
The type of communication channels carrying values of type 'a.
val new_channel : unit -> 'a channel The type of communication events returning a result of type 'a.
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 event always 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.
val wrap_abort : 'a event -> (unit -> unit) -> 'a event 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 -> '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.syncSome r where r is the result value of that communication. Otherwise, return None without blocking.
Map (ocaml.Export_id.Map) Up – ocaml » Export_id » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Export_id.Set) Up – ocaml » Export_id » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Export_id.T) Up – ocaml » Export_id » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Export_id.Tbl) Up – ocaml » Export_id » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Export_id (ocaml.Export_id) Up – ocaml » Export_idinclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val name : t -> string option Export_info (ocaml.Export_info) Up – ocaml » Export_infotype value_string_contents = | Contents of string| Unknown_or_mutable type value_float_array_contents = | Contents of float option array| Unknown_or_mutable A structure that describes what a single compilation unit exports.
Export information for a compilation unit that exports nothing.
Create a new export information structure.
Record information about the layout of closures and which sets of closures are constant. These are all worked out during the Flambda_to_clambda pass.
Union of export information. Verifies that there are no identifier clashes.
Look up the description of an exported value given its export ID.
Partition a mapping from export IDs by compilation unit.
Export_info_for_pack (ocaml.Export_info_for_pack) Up – ocaml » Export_info_for_packTransform 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.
val clear_import_state : unit -> unitDrops the state after importing several units in the same pack.
Expunge (ocaml.Expunge) Up – ocaml » ExpungeThe entry point for expunge
Extract_projections (ocaml.Extract_projections) Up – ocaml » Extract_projectionsModule 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.
which_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 (ocaml.Find_recursive_functions) Up – ocaml » Find_recursive_functionsModule Find_recursive_functions "Recursive functions" are those functions f that might call either:
themselves, or another function that in turn might call 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
Determine 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.
Map (ocaml.Flambda.Constant_defining_value.Map) Up – ocaml » Flambda » Constant_defining_value » MapModule Constant_defining_value.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Flambda.Constant_defining_value.Set) Up – ocaml » Flambda » Constant_defining_value » SetModule Constant_defining_value.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Flambda.Constant_defining_value.T) Up – ocaml » Flambda » Constant_defining_value » TModule Constant_defining_value.T include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Flambda.Constant_defining_value.Tbl) Up – ocaml » Flambda » Constant_defining_value » TblModule Constant_defining_value.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Constant_defining_value (ocaml.Flambda.Constant_defining_value) Up – ocaml » Flambda » Constant_defining_valueModule Flambda.Constant_defining_value include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
With_free_variables (ocaml.Flambda.With_free_variables) Up – ocaml » Flambda » With_free_variablesTakes 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)).
Takes the time required to calculate the free variables of the given expr.
val create_let_reusing_body : Variable.t -> named -> expr t -> expr Takes the time required to calculate the free variables of the given named.
The equivalent of the Expr constructor.
val contents : 'a t -> 'a Flambda (ocaml.Flambda) Up – ocaml » FlambdaWhether the callee in a function application is known at compile time.
type const = | Int of int| Char of charChar is kept separate from Int to improve printing
Simple constants. ("Structured constants" are rewritten to invocations of Pmakeblock so that they easily take part in optimizations.)
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.
The invocation of a method.
For details on these types, see projection.mli.
type specialised_to = { var : Variable.t ; 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.
Flambda 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 listDebuginfo.t | Expr of t 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 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 ; } and switch = { numconsts : Numbers.Int.Set.t ; consts : (int * t ) list numblocks : Numbers.Int.Set.t ; Number of tag block cases
blocks : (int * t ) list failaction : t option Action to take if none matched
} Equivalent to the similar type in Lambda.
Equivalent to the similar type in Lambda.
and constant_defining_value = | Allocated_const of Allocated_const.t A 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_closures A closed (and thus constant) set of closures. (That is to say, free_vars must be empty.)
| Project_closure of Symbol.t * Closure_id.t Selection 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).
and constant_defining_value_block_field = | Symbol of Symbol.t | Const of const type program_body = | Let_symbol of Symbol.t * constant_defining_value * program_body Define the given symbol to have the given constant value.
| Let_rec_symbol of (Symbol.t * constant_defining_value ) listprogram_body As 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 listprogram_body Define 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_body Cause 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.t End 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.t Compute 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.
Compute 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.t Compute _all_ variables occurring inside an expression.
Compute _all_ variables occurring inside a named expression.
Used 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 ) -> t Like fold_lets_option, but just a map.
val iter_lets :
+ t -> for_defining_expr :(Variable.t -> named -> -> for_last_body :(t -> -> for_each_let :(t -> -> Like map_lets, but just an iterator.
Creates 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.
A module for the manipulation of terms where the recomputation of free variable sets is to be kept to a minimum.
Create a function declaration. This calculates the free variables and symbols occurring in the specified body.
Create a function declaration based on another function declaration
Create a set of function declarations given the individual declarations.
Create a set of function declarations with a given set of closures origin.
Create a set of function declarations based on another set of function declarations.
Create a set of closures. Checks are made to ensure that free_vars and specialised_args are reasonable.
Given a function declaration, find which of its parameters (if any) are used in the body.
type maybe_named = | Is_expr of t | Is_named of named val iter_general :
+ toplevel :bool -> (t -> -> (named -> -> maybe_named -> This function is designed for the internal use of Flambda_iterators. See that module for iterators to be used over Flambda terms.
Flambda_invariants (ocaml.Flambda_invariants) Up – ocaml » Flambda_invariantsModule Flambda_invariants type flambda_kind = | Normal | Lifted Checking of invariants on Flambda expressions. Raises an exception if a check fails.
Flambda_iterators (ocaml.Flambda_iterators) Up – ocaml » Flambda_iteratorsApply 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.
iter_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).
Flambda_middle_end (ocaml.Flambda_middle_end) Up – ocaml » Flambda_middle_endFlambda_to_clambda (ocaml.Flambda_to_clambda) Up – ocaml » Flambda_to_clambdaModule Flambda_to_clambda Convert 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.
Switch_storer (ocaml.Flambda_utils.Switch_storer) Up – ocaml » Flambda_utils » Switch_storerFlambda_utils (ocaml.Flambda_utils) Up – ocaml » Flambda_utilsAccess functions
find_declaration f decl raises Not_found if f is not in decl.
find_declaration_variable f decl raises Not_found if f is not in decl.
find_free_variable v clos raises Not_found if c is not in clos.
Utility functions
Variables "bound by a closure" are those variables free in the corresponding function's body that are neither:
bound as parameters of that function; nor bound by the 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 -> bind [var1, expr1; ...; varN, exprN] body binds using Immutable Let expressions the given (var, expr) pairs around the body.
Returns true iff the given term might raise the given static exception.
Creates a map from closure IDs to set_of_closure IDs by iterating over all sets of closures in the given program.
The definitions of all constants that have been lifted out to Let_symbol or Let_rec_symbol constructions.
Like all_lifted_constant_symbols, but returns a map instead of a list.
The identifiers of all constant sets of closures that have been lifted out to Let_symbol or Let_rec_symbol constructions.
All sets of closures in the given program (whether or not bound to a symbol.)
For the compilation of switch statements.
Within 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".
type specialised_to_same_as = | Not_specialised | Specialised_and_aliased_to of Variable.Set.t For 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.
Project_var (ocaml.Freshening.Project_var) Up – ocaml » Freshening » Project_varModule Freshening.Project_var A 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 compose : earlier :t -> later :t -> t Composition of two freshenings.
Freshen 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.
Like apply_closure_id, but for variables within closures.
Freshening (ocaml.Freshening) Up – ocaml » FresheningA table used for freshening variables and static exception identifiers.
The freshening that does nothing. This is the unique inactive freshening.
Activate 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.
val empty_preserving_activation_state : t -> t Given the inactive freshening, return the same; otherwise, return an empty active freshening.
add_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.
Like add_variable, but for multiple variables, each freshened separately.
Like add_variables', but passes through the second component of the input list unchanged.
Like add_variable, but for mutable variables.
As for add_variable, but for static exception identifiers.
apply_variable t var applies the freshening t to var. If no renaming is specified in t for var it is returned unchanged.
As for apply_variable, but for mutable variables.
As for apply_variable, but for static exception identifiers.
Replace 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.
N.B. This does not freshen the domain of the supplied map, only the range.
O (ocaml.Genprintval.Make.O) Up – ocaml » Genprintval » Make » Oval field : t -> int -> t val double_array_tag : intval double_field : t -> int -> float_ (ocaml.Genprintval.Make._) Up – ocaml » Genprintval » Make » _Make (ocaml.Genprintval.Make) Up – ocaml » Genprintval » Makeinstall_generic_printer' function_path constructor_path printer function_path is used to remove the printer.
val remove_printer : Path.t -> Genprintval (ocaml.Genprintval) Up – ocaml » Genprintvalmodule type OBJ = sig ... end type ('a, 'b) gen_printer = | Zero of 'b | Succ of 'a -> ('a , 'b ) gen_printer module type S = sig ... end EVALPATH (ocaml.Genprintval.EVALPATH) Up – ocaml » Genprintval » EVALPATHModule type Genprintval.EVALPATH OBJ (ocaml.Genprintval.OBJ) Up – ocaml » Genprintval » OBJModule type Genprintval.OBJ val field : t -> int -> t val double_array_tag : intval double_field : t -> int -> floatS (ocaml.Genprintval.S) Up – ocaml » Genprintval » SModule type Genprintval.S install_generic_printer' function_path constructor_path printer function_path is used to remove the printer.
val remove_printer : Path.t -> Id (ocaml.Id_types.Id) Up – ocaml » Id_types » Idinclude BaseId val equal : t -> t -> val compare : t -> t -> val name : t -> string option val to_string : t -> val create : ?name :string -> unit -> t _ (ocaml.Id_types.UnitId._) Up – ocaml » Id_types » UnitId » _include BaseId val equal : t -> t -> val compare : t -> t -> val name : t -> string option val to_string : t -> val create : ?name :string -> unit -> t Compilation_unit (ocaml.Id_types.UnitId.Compilation_unit) Up – ocaml » Id_types » UnitId » Compilation_unitParameter UnitId.Compilation_unit include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
UnitId (ocaml.Id_types.UnitId) Up – ocaml » Id_types » UnitIdinclude BaseId val equal : t -> t -> val compare : t -> t -> val name : t -> string option val to_string : t -> Id_types (ocaml.Id_types) Up – ocaml » Id_typesmodule type BaseId = sig ... end module type Id = sig ... end module type UnitId = sig ... end Fully qualified identifiers
BaseId (ocaml.Id_types.BaseId) Up – ocaml » Id_types » BaseIdModule type Id_types.BaseId Generic identifier type
val equal : t -> t -> val compare : t -> t -> val name : t -> string option val to_string : t -> Id (ocaml.Id_types.Id) Up – ocaml » Id_types » Idinclude BaseId val equal : t -> t -> val compare : t -> t -> val name : t -> string option val to_string : t -> val create : ?name :string -> unit -> t Compilation_unit (ocaml.Id_types.UnitId.Compilation_unit) Up – ocaml » Id_types » UnitId » Compilation_unitModule UnitId.Compilation_unit include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
UnitId (ocaml.Id_types.UnitId) Up – ocaml » Id_types » UnitIdinclude BaseId val equal : t -> t -> val compare : t -> t -> val name : t -> string option val to_string : t -> Map (ocaml.Ident.Map) Up – ocaml » Ident » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Ident.Set) Up – ocaml » Ident » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Ident.T) Up – ocaml » Ident » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Ident.Tbl) Up – ocaml » Ident » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Ident (ocaml.Ident) Up – ocaml » Identinclude Identifiable.S with type t := t include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Same as printn" suffix if the scope of the argument is n.
val create_scoped : scope :int -> string -> t val create_local : string -> t val create_persistent : string -> t val create_predef : string -> t Creates an identifier with the same name as the input, a fresh stamp, and no scope.
val unique_name : t -> val unique_toplevel_name : t -> val persistent : t -> val same : t -> t -> Compare 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 compare : t -> t -> val is_predef : t -> val reinit : unit -> unit'a tbl represents association tables from identifiers to values of type 'a.
'a tbl plays the role of map, but bindings can be looked up from either the full Ident using find_same, or just its user-visible name using find_name. In general the two lookups may not return the same result, as an identifier may have been shadowed in the environment by a distinct identifier with the same name.
find_all returns the bindings for all idents of a given name, most recently introduced first.
In other words, 'a tbl corresponds to (Ident.t * 'a) list Map.Make(String) and the implementation is very close to that representation.
Note in particular that searching among idents of the same name takes linear time, and that add simply extends the list without checking for duplicates. So it is not a good idea to implement union by repeated add calls, which may result in many duplicated identifiers and poor find_same performance. It is even possible to build overly large same-name lists such that non-recursive functions like find_all or fold_all blow the stack.
You should probably use Map.Make(Ident) instead, unless you really need to query bindings by user-visible name, not just by unique identifiers.
val add : t -> 'a -> 'a tbl -> 'a tbl val find_same : t -> 'a tbl -> 'a val find_name : string -> 'a tbl -> t * 'a val find_all : string -> 'a tbl -> (t * 'a ) listval fold_name : (t -> 'a -> 'b -> 'b ) -> 'a tbl -> 'b -> 'b val fold_all : (t -> 'a -> 'b -> 'b ) -> 'a tbl -> 'b -> 'b val iter : (t -> 'a -> -> 'a tbl -> val make_key_generator : unit -> t -> t Map (ocaml.Identifiable.Make.Map) Up – ocaml » Identifiable » Make » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Identifiable.Make.Set) Up – ocaml » Identifiable » Make » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Identifiable.Make.T) Up – ocaml » Identifiable » Make » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Identifiable.Make.Tbl) Up – ocaml » Identifiable » Make » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t T (ocaml.Identifiable.Make.T) Up – ocaml » Identifiable » Make » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Make (ocaml.Identifiable.Make) Up – ocaml » Identifiable » Makeinclude Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
A (ocaml.Identifiable.Pair.A) Up – ocaml » Identifiable » Pair » Ainclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
B (ocaml.Identifiable.Pair.B) Up – ocaml » Identifiable » Pair » Binclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Pair (ocaml.Identifiable.Pair) Up – ocaml » Identifiable » Pairinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Identifiable (ocaml.Identifiable) Up – ocaml » IdentifiableModule Identifiable Uniform interface for common data structures over various things.
Warning: this module is unstable and part of compiler-libs .
module type Thing = sig ... end module type Set = sig ... end module type Map = sig ... end module type Tbl = sig ... end module type S = sig ... end T (ocaml.Identifiable.Map.T) Up – ocaml » Identifiable » Map » TThe type of the map keys.
val compare : t -> t -> 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 (ocaml.Identifiable.Map) Up – ocaml » Identifiable » MapModule type Identifiable.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Map (ocaml.Identifiable.S.Map) Up – ocaml » Identifiable » S » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Identifiable.S.Set) Up – ocaml » Identifiable » S » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Identifiable.S.T) Up – ocaml » Identifiable » S » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Identifiable.S.Tbl) Up – ocaml » Identifiable » S » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t S (ocaml.Identifiable.S) Up – ocaml » Identifiable » SModule type Identifiable.S include Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
T (ocaml.Identifiable.Set.T) Up – ocaml » Identifiable » Set » TThe type of the set elements.
val compare : t -> t -> 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 (ocaml.Identifiable.Set) Up – ocaml » Identifiable » SetModule type Identifiable.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Identifiable.Tbl.T) Up – ocaml » Identifiable » Tbl » Tinclude Map.OrderedType with type t := t val compare : t -> t -> 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
include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Tbl (ocaml.Identifiable.Tbl) Up – ocaml » Identifiable » TblModule type Identifiable.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Thing (ocaml.Identifiable.Thing) Up – ocaml » Identifiable » ThingModule type Identifiable.Thing include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Import_approx (ocaml.Import_approx) Up – ocaml » Import_approxGiven 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.
Maps the description of the given approximation through really_import.
Read 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.
Includeclass (ocaml.Includeclass) Up – ocaml » IncludeclassIncludecore (ocaml.Includecore) Up – ocaml » Includecoretype primitive_mismatch = | Name | Arity | No_alloc of position | Native_name | Result_repr | Argument_repr of inttype privacy_mismatch = | Private_type_abbreviation | Private_variant_type | Private_record_type | Private_extensible_variant | Private_row_type type type_kind = | Kind_abstract | Kind_record | Kind_variant | Kind_open type private_variant_mismatch = | Only_outer_closed | Missing of position * string| Presence of string| Incompatible_types_for of string| Types of Errortrace.equality_error Error (ocaml.Includemod.Error) Up – ocaml » Includemod » Errortype ('elt, 'explanation) diff = { got : 'elt ; expected : 'elt ; symptom : 'explanation ; } type 'elt core_diff = ('elt , unit) diff type functor_arg_descr = | Anonymous | Named of Path.t | Unit | Empty_struct For backward compatibility's sake, an empty struct can be implicitly converted to an unit module.
type core_module_type_symptom = | Not_an_alias | Not_an_identifier | Incompatible_aliases | Abstract_module_type | Unbound_module_path of Path.t FieldMap (ocaml.Includemod.FieldMap) Up – ocaml » Includemod » FieldMapThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Defs (ocaml.Includemod.Functor_app_diff.Defs) Up – ocaml » Includemod » Functor_app_diff » DefsModule Functor_app_diff.Defs Functor_app_diff (ocaml.Includemod.Functor_app_diff) Up – ocaml » Includemod » Functor_app_diffModule Includemod.Functor_app_diff module Defs : sig ... end Defs (ocaml.Includemod.Functor_inclusion_diff.Defs) Up – ocaml » Includemod » Functor_inclusion_diff » DefsModule Functor_inclusion_diff.Defs Functor_inclusion_diff (ocaml.Includemod.Functor_inclusion_diff) Up – ocaml » Includemod » Functor_inclusion_diffModule Includemod.Functor_inclusion_diff module Defs : sig ... end Includemod (ocaml.Includemod) Up – ocaml » Includemodtype mark = | Mark_both Mark definitions used from both arguments
| Mark_positive Mark definitions used from the positive (first) argument
| Mark_negative Mark definitions used from the negative (second) argument
| Mark_neither Do not mark definitions used from either argument
Type describing which arguments of an inclusion to consider as used for the usage warnings. Mark_both is the default.
module Error : sig ... end type field_kind = | Field_value | Field_type | Field_exception | Field_typext | Field_module | Field_modtype | Field_class | Field_classtype type field_desc = { name : string; kind : field_kind ; } Map indexed by both field types and names. This avoids name clashes between different sorts of fields such as values and types.
check_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.
Includemod_errorprinter (ocaml.Includemod_errorprinter) Up – ocaml » Includemod_errorprinterModule Includemod_errorprinter val register : unit -> unitInconstant_idents (ocaml.Inconstant_idents) Up – ocaml » Inconstant_identsinconstants_on_program finds those variables and set-of-closures identifiers that cannot be compiled to constants by Flambda_to_clambda.
variable var res returns true if var is marked as inconstant in res.
closure cl res returns true if cl is marked as inconstant in res.
Initialize_symbol_to_let_symbol (ocaml.Initialize_symbol_to_let_symbol) Up – ocaml » Initialize_symbol_to_let_symbolModule Initialize_symbol_to_let_symbol Transform Initialize_symbol with only constant fields to let_symbol construction.
Inline_and_simplify (ocaml.Inline_and_simplify) Up – ocaml » Inline_and_simplifyModule Inline_and_simplify Simplification 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.
Env (ocaml.Inline_and_simplify_aux.Env) Up – ocaml » Inline_and_simplify_aux » EnvModule Inline_and_simplify_aux.Env Environments follow the lexical scopes of the program.
Create 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.
Obtain the first-class module that gives information about the compiler backend being used for compilation.
Obtain the really_import_approx function from the backend module.
Which simplification round we are currently in.
Where to print intermediate asts and similar debug information
Add 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.
Like add, but for mutable variables.
Find 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.
Like find_exn, but for mutable variables.
type scope = | Current | Outer Like find_exn, but intended for use where the "not present in environment" case is to be handled by the caller.
Like find_exn, but for a list of variables.
Note that the given bound_to holds the given projection.
Determine if the environment knows about a variable that is bound to the given projection.
Whether the environment has an approximation for the given variable.
Return the freshening that should be applied to variables when rewriting code (in Inline_and_simplify, etc.) using the given environment.
Set the freshening that should be used as per freshening, above.
val activate_freshening : t -> t 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.
Determine 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 -> Not inside a closure declaration. Toplevel code is the one evaluated when the compilation unit is loaded
val is_inside_branch : t -> val branch_depth : t -> val inside_branch : t -> t val increase_closure_depth : t -> t val set_never_inline : t -> t Mark that call sites contained within code rewritten using the given environment should never be replaced by inlined (or unrolled) versions of the callee(s).
val set_never_inline_inside_closures : t -> t Equivalent to set_never_inline but only applies to code inside a set of closures.
val unset_never_inline_inside_closures : t -> t Unset the restriction from set_never_inline_inside_closures
val set_never_inline_outside_closures : t -> t Equivalent to set_never_inline but does not apply to code inside a set of closures.
val unset_never_inline_outside_closures : t -> t Unset the restriction from set_never_inline_outside_closures
val never_inline : t -> Return whether set_never_inline is currently in effect on the given environment.
val inlining_level : t -> val inlining_level_up : t -> t Mark 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.
Whether we are actively unrolling a given function.
Start actively unrolling a given function n times.
Unroll a function currently actively being unrolled.
Whether it is permissible to unroll a call to a recursive function in the given environment.
Whether the given environment is currently being used to rewrite the body of an unrolled recursive function.
Whether it is permissible to inline a call to a function in the given environment.
Whether the given environment is currently being used to rewrite the body of an inlined function.
If 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.
If 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.
val note_entering_inlined : t -> t 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.
If 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.
Update 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).
If collecting inlining statistics, record an inlining decision for the call at the top of the closure stack stored inside the given environment.
Print a human-readable version of the given environment.
The environment stores the call-site being inlined to produce precise location information. This function sets the current call-site being inlined.
Appends the locations of inlined call-sites to the ~dbg argument
Result (ocaml.Inline_and_simplify_aux.Result) Up – ocaml » Inline_and_simplify_aux » ResultModule Inline_and_simplify_aux.Result Result structures approximately follow the evaluation order of the program. They are returned by the simplification algorithm acting on an Flambda subexpression.
The approximation of the subexpression that has just been simplified.
Set the approximation of the subexpression that has just been simplified. Typically used just before returning from a case of the simplification algorithm.
Set 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.
All static exceptions for which use_staticfail has been called on the given result structure.
Mark that the given static exception has been used.
Mark 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.
The benefit to be gained by inlining the subexpression whose simplification yielded the given result structure.
Apply a transformation to the inlining benefit stored within the given result structure.
Add some benefit to the inlining benefit stored within the given result structure.
val reset_benefit : t -> t Set the benefit of inlining the subexpression corresponding to the given result structure to zero.
val seen_direct_application : t -> t val num_direct_applications : t -> Inline_and_simplify_aux (ocaml.Inline_and_simplify_aux) Up – ocaml » Inline_and_simplify_auxCommand line argument -inline
Command line argument -inline-toplevel
Benefit (ocaml.Inlining_cost.Benefit) Up – ocaml » Inlining_cost » BenefitModule Inlining_cost.Benefit val max : round :int -> t -> t -> t val remove_alloc : t -> t val remove_prims : t -> int -> t val remove_branch : t -> t val direct_call_of_indirect : t -> t Threshold (ocaml.Inlining_cost.Threshold) Up – ocaml » Inlining_cost » ThresholdModule Inlining_cost.Threshold type t = | Never_inline | Can_inline_if_no_larger_than of intThe maximum size, in some abstract measure of space cost, that an Flambda expression may be in order to be inlined.
val equal : t -> t -> Whether_sufficient_benefit (ocaml.Inlining_cost.Whether_sufficient_benefit) Up – ocaml » Inlining_cost » Whether_sufficient_benefitModule Inlining_cost.Whether_sufficient_benefit val create :
+ original :Flambda.t -> toplevel :bool -> branch_depth :int -> Flambda.t -> benefit :Benefit.t -> lifting :bool -> round :int -> t val create_estimate :
+ original_size :int -> toplevel :bool -> branch_depth :int -> new_size :int -> benefit :Benefit.t -> lifting :bool -> round :int -> t val to_string : t -> Inlining_cost (ocaml.Inlining_cost) Up – ocaml » Inlining_costval scale_inline_threshold_by : intval default_toplevel_multiplier : intval direct_call_size : intval maximum_interesting_size_of_function_body : int -> intIf 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 option Measure 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.
Inlining_decision (ocaml.Inlining_decision) Up – ocaml » Inlining_decisionTry to inline a full application of a known function, guided by various heuristics.
When 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_intf (ocaml.Inlining_decision_intf) Up – ocaml » Inlining_decision_intfModule Inlining_decision_intf Closure_stack (ocaml.Inlining_stats.Closure_stack) Up – ocaml » Inlining_stats » Closure_stackModule Inlining_stats.Closure_stack val note_entering_inlined : t -> t Inlining_stats (ocaml.Inlining_stats) Up – ocaml » Inlining_statsval save_then_forget_decisions : output_prefix :string -> Decision (ocaml.Inlining_stats_types.Decision) Up – ocaml » Inlining_stats_types » DecisionModule Inlining_stats_types.Decision Inlined (ocaml.Inlining_stats_types.Inlined) Up – ocaml » Inlining_stats_types » InlinedModule Inlining_stats_types.Inlined Not_inlined (ocaml.Inlining_stats_types.Not_inlined) Up – ocaml » Inlining_stats_types » Not_inlinedModule Inlining_stats_types.Not_inlined Not_specialised (ocaml.Inlining_stats_types.Not_specialised) Up – ocaml » Inlining_stats_types » Not_specialisedModule Inlining_stats_types.Not_specialised Prevented (ocaml.Inlining_stats_types.Prevented) Up – ocaml » Inlining_stats_types » PreventedModule Inlining_stats_types.Prevented type t = | Function_prevented_from_inlining | Level_exceeded Specialised (ocaml.Inlining_stats_types.Specialised) Up – ocaml » Inlining_stats_types » SpecialisedModule Inlining_stats_types.Specialised Inlining_stats_types (ocaml.Inlining_stats_types) Up – ocaml » Inlining_stats_typesModule Inlining_stats_types Inlining_transforms (ocaml.Inlining_transforms) Up – ocaml » Inlining_transformsInline 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:
inlining a call to a non-recursive function; inlining a call, within a recursive or mutually-recursive function, to the same or another function being defined simultaneously ("unrolling"). The maximum depth of unrolling is bounded (see 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 *)
Inlining 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.
Instruct (ocaml.Instruct) Up – ocaml » Instructand debug_event_kind = | Event_before | Event_after of Types.type_expr | Event_pseudo and debug_event_info = | Event_function | Event_return of int| Event_other and debug_event_repr = | Event_none | Event_parent of int ref | Event_child of int ref 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| 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 arraylabel 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 | Kperform | Kresume | Kresumeterm of int| Kreperformterm of int| Kstop Int_replace_polymorphic_compare (ocaml.Int_replace_polymorphic_compare) Up – ocaml » Int_replace_polymorphic_compareModule Int_replace_polymorphic_compare val (=) : int -> int -> boolval (<>) : int -> int -> boolval (<) : int -> int -> boolval (>) : int -> int -> boolval (<=) : int -> int -> boolval (>=) : int -> int -> boolval compare : int -> int -> intInterf (ocaml.Interf) Up – ocaml » InterfInternal_variable_names (ocaml.Internal_variable_names) Up – ocaml » Internal_variable_namesModule Internal_variable_names val block_symbol_get_field : t val dup_set_of_closures : t val const_float_array : t val fake_effect_symbol : t val lifted_let_rec_block : t val remove_unused_arguments : t val symbol_field_block : t val the_dead_constant : t val toplevel_substitution_named : t val unbox_free_vars_of_closures : t Interval (ocaml.Interval) Up – ocaml » Intervaltype range = { mutable rbegin : int;mutable rend : int;} type t = { mutable reg : Reg.t ;mutable ibegin : int;mutable iend : int;mutable ranges : range list} type result = { intervals : t list fixed_intervals : t list } val overlap : t -> t -> val is_live : t -> int -> boolval remove_expired_ranges : t -> int -> unitInvariant_params (ocaml.Invariant_params) Up – ocaml » Invariant_paramsLambda (ocaml.Lambda) Up – ocaml » Lambdatype compile_time_constant = | Big_endian | Word_size | Int_size | Max_wosize | Ostype_unix | Ostype_win32 | Ostype_cygwin | Backend_type type initialization_or_assignment = | Assignment | Heap_initialization | Root_initialization type is_safe = | Safe | Unsafe and integer_comparison = | Ceq | Cne | Clt | Cgt | Cle | Cge and float_comparison = | CFeq | CFneq | CFlt | CFnlt | CFgt | CFngt | CFle | CFnle | CFge | CFnge and array_kind = | Pgenarray | Paddrarray | Pintarray | Pfloatarray and value_kind = | Pgenval | Pfloatval | Pboxedintval of boxed_integer | Pintval and bigarray_kind = | Pbigarray_unknown | Pbigarray_float32 | Pbigarray_float64 | Pbigarray_sint8 | Pbigarray_uint8 | Pbigarray_sint16 | Pbigarray_uint16 | Pbigarray_int32 | Pbigarray_int64 | Pbigarray_caml_int | Pbigarray_native_int | Pbigarray_complex32 | Pbigarray_complex64 and bigarray_layout = | Pbigarray_unknown_layout | Pbigarray_c_layout | Pbigarray_fortran_layout and raise_kind = | Raise_regular | Raise_reraise | Raise_notrace type tailcall_attribute = | Tailcall_expectation of bool| Default_tailcall type inline_attribute = | Always_inline | Never_inline | Hint_inline | Unroll of int| Default_inline type specialise_attribute = | Always_specialise | Never_specialise | Default_specialise type local_attribute = | Always_local | Never_local | Default_local type poll_attribute = | Error_poll | Default_poll type function_kind = | Curried | Tupled type let_kind = | Strict | Alias | StrictOpt type meth_kind = | Self | Public | Cached type shared_code = (int * int) list and lambda_switch = { sw_numconsts : int; sw_consts : (int * lambda ) list sw_numblocks : int; sw_blocks : (int * lambda ) list sw_failaction : lambda option } and lambda_event_kind = | Lev_before | Lev_after of Types.type_expr | Lev_function | Lev_pseudo val iter_head_constructor : (lambda -> -> lambda -> iter_head_constructor f lam apply f to only the first level of sub expressions of lam. It does not recursively traverse the expression.
val shallow_iter :
+ tail :(lambda -> -> non_tail :(lambda -> -> lambda -> 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 -> lambda Translate a value from a persistent module. For instance:
transl_internal_value "CamlinternalLazy" "force"subst 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.
A version of subst specialized for the case where we're just renaming idents.
Duplicate a term, freshening all locally-bound identifiers.
Bottom-up rewriting, applying the function on each node from the leaves to the root.
Rewrite each immediate sub-term with the function.
val max_arity : unit -> intMaximal 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 next_raise_count : unit -> intval is_guarded : lambda -> Lazy_backtrack (ocaml.Lazy_backtrack) Up – ocaml » Lazy_backtrackval force : ('a -> 'b ) -> ('a , 'b ) t -> 'b val create : 'a -> ('a , 'b ) t val get_arg : ('a , 'b ) t -> 'a optionval create_forced : 'b -> ('a , 'b ) t val create_failed : exn -> ('a , 'b ) t val backtrack : log -> Lexer (ocaml.Lexer) Up – ocaml » Lexertype error = | Illegal_character of char| Illegal_escape of string * string option | Reserved_sequence of string * string option | Unterminated_string | Empty_character_literal | Keyword_as_label of string| Invalid_literal of string| Invalid_directive of string * string option
val in_string : unit -> boolval print_warnings : bool ref val handle_docstrings : bool ref
Lift_code (ocaml.Lift_code) Up – ocaml » Lift_codeLift 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>
Lift_constants (ocaml.Lift_constants) Up – ocaml » Lift_constantsModule 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.
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).
Lift_let_to_initialize_symbol (ocaml.Lift_let_to_initialize_symbol) Up – ocaml » Lift_let_to_initialize_symbolModule Lift_let_to_initialize_symbol Lift 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).
Linear (ocaml.Linear) Up – ocaml » Lineartype fundecl = { fun_name : string; fun_args : Reg.Set.t ; 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_format (ocaml.Linear_format) Up – ocaml » Linear_formattype linear_unit_info = { mutable unit_name : string;mutable items : linear_item_info listmutable for_pack : string option ;} Linearize (ocaml.Linearize) Up – ocaml » LinearizeMap (ocaml.Linkage_name.Map) Up – ocaml » Linkage_name » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Linkage_name.Set) Up – ocaml » Linkage_name » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Linkage_name.T) Up – ocaml » Linkage_name » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Linkage_name.Tbl) Up – ocaml » Linkage_name » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Linkage_name (ocaml.Linkage_name) Up – ocaml » Linkage_nameinclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val to_string : t -> Linscan (ocaml.Linscan) Up – ocaml » LinscanLiveness (ocaml.Liveness) Up – ocaml » LivenessDir (ocaml.Load_path.Dir) Up – ocaml » Load_path » DirRepresent one directory in the load path.
val files : t -> string list All the files in that directory. This doesn't include files in sub-directories of this directory.
val find : t -> string -> string option find dir fn returns the full path to fn in dir.
val find_uncap : t -> string -> string option As find
Load_path (ocaml.Load_path) Up – ocaml » Load_pathModule Load_path Management 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.
val add_dir : string -> unitAdd a directory to the end of the load path (i.e. at lowest priority.)
val remove_dir : string -> unitRemove a directory from the load path
type auto_include_callback =
+ (Dir.t -> string -> string option ) -> string ->
+ string The type of callback functions on for init ~auto_include
No automatic directory inclusion: misses in the load path raise Not_found as normal.
init l is the same as reset (); List.iter add_dir (List.rev l)
auto_include_otherlibs alert is a callback function to be passed to Load_path.init-I +lib to the load path after calling alert lib.
val get_paths : unit -> string list Return the list of directories passed to add_dir so far.
val find : string -> stringLocate 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.
val find_uncap : string -> stringSame 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.
val append_dir : Dir.t -> append_dir d adds d to the end of the load path (i.e. at lowest priority.
val prepend_dir : Dir.t -> prepend_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_store (ocaml.Local_store) Up – ocaml » Local_storeModule Local_store This 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.
Similar to Stdlib.ref
val s_table : ('a -> 'b ) -> 'a -> 'b ref Used 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 -> store Returns 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 ) -> 'a with_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).
val is_bound : unit -> boolReturns true when a store is active (i.e. when called from the callback passed to with_storefalse otherwise.
Location (ocaml.Location) Up – ocaml » LocationModule Location Source code locations (ranges of positions), used in parsetree.
Warning: this module is unstable and part of compiler-libs .
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.
An arbitrary value of type t; describes an empty ghost range.
True for Location.none, false any other location
val in_file : string -> t Return an empty ghost range located in a given file.
Set the file name and line number of the lexbuf to be the start of the named file.
Get the location of the current token from the lexbuf.
val symbol_rloc : unit -> t val symbol_gloc : unit -> t rhs_loc n returns the location of the symbol at position n, starting at 1, in the current parser rule.
val rhs_interval : int -> int -> t type 'a loc = { txt : 'a ; loc : t ; } val mknoloc : 'a -> 'a loc val mkloc : 'a -> t -> 'a loc val echo_eof : unit -> unitval rewrite_absolute_path : string -> stringrewrite_absolute_path path rewrites path to honor the BUILD_PATH_PREFIX_MAP variable if it is set. It does not check whether path is absolute or not. The result is as follows:
If BUILD_PATH_PREFIX_MAP is not set, just return path. otherwise, rewrite using the mapping (and if there are no matching prefixes that will just return path). See the BUILD_PATH_PREFIX_MAP spec
val rewrite_find_first_existing : string -> string option rewrite_find_first_existing path uses a BUILD_PATH_PREFIX_MAP mapping and tries to find a source in mapping that maps to a result that exists in the file system. There are the following return values:
See the BUILD_PATH_PREFIX_MAP spec
val rewrite_find_all_existing_dirs : string -> string list rewrite_find_all_existing_dirs dir accumulates a list of existing directories, dirs, that are the result of mapping a potentially abstract directory, dir, over all the mapping pairs in the BUILD_PATH_PREFIX_MAP environment variable, if any. The list dirs will be in priority order (head as highest priority).
The possible results are:
See the BUILD_PATH_PREFIX_MAP spec
val absolute_path : string -> stringabsolute_path path first makes an absolute path, s from path, prepending the current working directory if path was relative. Then s is rewritten using rewrite_absolute_path. Finally the result is normalized by eliminating instances of '.' or '..'.
val show_filename : string -> stringIn -absname mode, return the absolute path for this filename. Otherwise, returns the filename unchanged.
type report_kind = | Report_error | Report_warning of string| Report_warning_as_error of string| Report_alert of string| Report_alert_as_error of stringA 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.
Detects the terminal capabilities and selects an adequate printer
reportDisplay an error or warning report.
Hook 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.
Original report printer for use in hooks.
Warnings.t into a reportreport_warning loc w produces a report for the given warning w, or None if the warning is not to be printed.
Hook for intercepting warnings.
Original warning reporter for use in hooks.
Prints a warning. This is simply the composition of report_warning and print_report.
Same as print_warning, but uses !formatter_for_warnings as output formatter.
Alert.t into a reportreport_alert loc w produces a report for the given alert w, or None if the alert is not to be printed.
Hook for intercepting alerts.
Original alert reporter for use in hooks.
Prints an alert. This is simply the composition of report_alert and print_report.
Same as print_alert, but uses !formatter_for_warnings as output formatter.
val deprecated : ?def :t -> ?use :t -> t -> string -> unitPrints a deprecation alert.
val alert : ?def :t -> ?use :t -> kind :string -> t -> string -> unitPrints an arbitrary alert.
val auto_include_alert : string -> unitPrints an alert that -I +lib has been automatically added to the load path
val deprecated_script_alert : string -> unitdeprecated_script_alert command prints an alert that command foo has been deprecated in favour of command ./foo
An error is a report which report_kind must be Report_error.
val error : ?loc :t -> ?sub :msg list-> string -> error val register_error_of_exn : (exn -> error option -> Each 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 ] optionRaising Error e signals an error e; the exception will be caught and the error will be printed.
exception Already_displayed_error Raising Already_displayed_error signals an error which has already been printed. The exception will be caught, but nothing will be printed
Reraise the exception if it is unknown.
Longident (ocaml.Longident) Up – ocaml » LongidentModule Longident Long identifiers, used in parsetree.
Warning: this module is unstable and part of compiler-libs .
To print a longident, see Pprintast.longidentFormat.asprintf to convert to a string.
type t = | Lident of string| Ldot of t * string| Lapply of t * t val flatten : t -> string list val 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.
This 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 unflattenunflatten
If you want to parse any identifier correctly, use the long-identifiers functions from the ParseParse.longident
Mach (ocaml.Mach) Up – ocaml » Machtype integer_operation = | Iadd | Isub | Imul | Imulh | Idiv | Imod | Iand | Ior | Ixor | Ilsl | Ilsr | Iasr | Icomp of integer_comparison | Icheckbound Returns 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.
Returns true if the given operation can raise an exception.
Main (ocaml.Main) Up – ocaml » Main
diff --git a/ocaml/Main_args/Default/Main/index.html b/ocaml/Main_args/Default/Main/index.html
new file mode 100644
index 00000000..67711ef7
--- /dev/null
+++ b/ocaml/Main_args/Default/Main/index.html
@@ -0,0 +1,2 @@
+
+Main (ocaml.Main_args.Default.Main) Up – ocaml » Main_args » Default » Maininclude Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitinclude Compiler_options val _annot : unit -> unitval _binannot : unit -> unitval _cclib : string -> unitval _ccopt : string -> unitval _cmi_file : string -> unitval _config : unit -> unitval _config_var : string -> unitval _for_pack : string -> unitval _stop_after : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _keep_docs : unit -> unitval _no_keep_docs : unit -> unitval _keep_locs : unit -> unitval _no_keep_locs : unit -> unitval _linkall : unit -> unitval _noautolink : unit -> unitval _opaque : unit -> unitval _output_obj : unit -> unitval _output_complete_obj : unit -> unitval _plugin : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _runtime_variant : string -> unitval _with_runtime : unit -> unitval _without_runtime : unit -> unitval _short_paths : unit -> unitval _thread : unit -> unitval _verbose : unit -> unitval _where : unit -> unitval _color : string -> unitval _error_style : string -> unitval _match_context_rows : int -> unitval _dtimings : unit -> unitval _dprofile : unit -> unitval _dump_into_file : unit -> unitval _dump_dir : string -> unitval _args : string -> string array val _args0 : string -> string array val _compat_32 : unit -> unitval _custom : unit -> unitval _no_check_prims : unit -> unitval _dllib : string -> unitval _dllpath : string -> unitval _make_runtime : unit -> unitval _vmthread : unit -> unitval _use_runtime : string -> unitval _output_complete_exe : unit -> unitval _dinstr : unit -> unitval _dcamlprimc : unit -> unitval _use_prims : string -> unitOdoc_args (ocaml.Main_args.Default.Odoc_args) Up – ocaml » Main_args » Default » Odoc_argsinclude Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _thread : unit -> unitval _verbose : unit -> unitval _vmthread : unit -> unitOptmain (ocaml.Main_args.Default.Optmain) Up – ocaml » Main_args » Default » Optmaininclude Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitinclude Compiler_options val _annot : unit -> unitval _binannot : unit -> unitval _cclib : string -> unitval _ccopt : string -> unitval _cmi_file : string -> unitval _config : unit -> unitval _config_var : string -> unitval _for_pack : string -> unitval _stop_after : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _keep_docs : unit -> unitval _no_keep_docs : unit -> unitval _keep_locs : unit -> unitval _no_keep_locs : unit -> unitval _linkall : unit -> unitval _noautolink : unit -> unitval _opaque : unit -> unitval _output_obj : unit -> unitval _output_complete_obj : unit -> unitval _plugin : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _runtime_variant : string -> unitval _with_runtime : unit -> unitval _without_runtime : unit -> unitval _short_paths : unit -> unitval _thread : unit -> unitval _verbose : unit -> unitval _where : unit -> unitval _color : string -> unitval _error_style : string -> unitval _match_context_rows : int -> unitval _dtimings : unit -> unitval _dprofile : unit -> unitval _dump_into_file : unit -> unitval _dump_dir : string -> unitval _args : string -> string array val _args0 : string -> string array include Optcommon_options val _compact : unit -> unitval _inline : string -> unitval _inline_toplevel : string -> unitval _inlining_report : unit -> unitval _dump_pass : string -> unitval _inline_max_depth : string -> unitval _rounds : int -> unitval _inline_max_unroll : string -> unitval _classic_inlining : unit -> unitval _inline_call_cost : string -> unitval _inline_alloc_cost : string -> unitval _inline_prim_cost : string -> unitval _inline_branch_cost : string -> unitval _inline_indirect_cost : string -> unitval _inline_lifting_benefit : string -> unitval _unbox_closures : unit -> unitval _unbox_closures_factor : int -> unitval _inline_branch_factor : string -> unitval _remove_unused_arguments : unit -> unitval _no_unbox_free_vars_of_closures : unit -> unitval _no_unbox_specialised_args : unit -> unitval _insn_sched : unit -> unitval _no_insn_sched : unit -> unitval _linscan : unit -> unitval _no_float_const_prop : unit -> unitval _clambda_checks : unit -> unitval _dflambda : unit -> unitval _drawflambda : unit -> unitval _dflambda_invariants : unit -> unitval _dflambda_no_invariants : unit -> unitval _dflambda_let : int -> unitval _dflambda_verbose : unit -> unitval _drawclambda : unit -> unitval _dclambda : unit -> unitval _dcmm_invariants : unit -> unitval _dcombine : unit -> unitval _dlive : unit -> unitval _dspill : unit -> unitval _dsplit : unit -> unitval _dinterf : unit -> unitval _dprefer : unit -> unitval _dalloc : unit -> unitval _dreload : unit -> unitval _dscheduling : unit -> unitval _dlinear : unit -> unitval _dinterval : unit -> unitval _dstartup : unit -> unitval _nodynlink : unit -> unitval _shared : unit -> unitval _afl_instrument : unit -> unitval _afl_inst_ratio : int -> unitval _function_sections : unit -> unitval _save_ir_after : string -> unitOpttopmain (ocaml.Main_args.Default.Opttopmain) Up – ocaml » Main_args » Default » OpttopmainModule Default.Opttopmain include Toplevel_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitval _init : string -> unitval _noinit : unit -> unitval _no_version : unit -> unitval _noprompt : unit -> unitval _nopromptcont : unit -> unitval _stdin : unit -> unitval _args : string -> string array val _args0 : string -> string array val _color : string -> unitval _error_style : string -> unitval _eval : string -> unitinclude Optcommon_options val _compact : unit -> unitval _inline : string -> unitval _inline_toplevel : string -> unitval _inlining_report : unit -> unitval _dump_pass : string -> unitval _inline_max_depth : string -> unitval _rounds : int -> unitval _inline_max_unroll : string -> unitval _classic_inlining : unit -> unitval _inline_call_cost : string -> unitval _inline_alloc_cost : string -> unitval _inline_prim_cost : string -> unitval _inline_branch_cost : string -> unitval _inline_indirect_cost : string -> unitval _inline_lifting_benefit : string -> unitval _unbox_closures : unit -> unitval _unbox_closures_factor : int -> unitval _inline_branch_factor : string -> unitval _remove_unused_arguments : unit -> unitval _no_unbox_free_vars_of_closures : unit -> unitval _no_unbox_specialised_args : unit -> unitval _insn_sched : unit -> unitval _no_insn_sched : unit -> unitval _linscan : unit -> unitval _no_float_const_prop : unit -> unitval _clambda_checks : unit -> unitval _dflambda : unit -> unitval _drawflambda : unit -> unitval _dflambda_invariants : unit -> unitval _dflambda_no_invariants : unit -> unitval _dflambda_let : int -> unitval _dflambda_verbose : unit -> unitval _drawclambda : unit -> unitval _dclambda : unit -> unitval _dcmm_invariants : unit -> unitval _dcombine : unit -> unitval _dlive : unit -> unitval _dspill : unit -> unitval _dsplit : unit -> unitval _dinterf : unit -> unitval _dprefer : unit -> unitval _dalloc : unit -> unitval _dreload : unit -> unitval _dscheduling : unit -> unitval _dlinear : unit -> unitval _dinterval : unit -> unitval _dstartup : unit -> unitval _verbose : unit -> unitTopmain (ocaml.Main_args.Default.Topmain) Up – ocaml » Main_args » Default » Topmaininclude Toplevel_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitval _init : string -> unitval _noinit : unit -> unitval _no_version : unit -> unitval _noprompt : unit -> unitval _nopromptcont : unit -> unitval _stdin : unit -> unitval _args : string -> string array val _args0 : string -> string array val _color : string -> unitval _error_style : string -> unitval _eval : string -> unitval _dinstr : unit -> unitDefault (ocaml.Main_args.Default) Up – ocaml » Main_args » Default_ (ocaml.Main_args.Make_bytecomp_options._) Up – ocaml » Main_args » Make_bytecomp_options » _Parameter Make_bytecomp_options._ include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitinclude Compiler_options val _annot : unit -> unitval _binannot : unit -> unitval _cclib : string -> unitval _ccopt : string -> unitval _cmi_file : string -> unitval _config : unit -> unitval _config_var : string -> unitval _for_pack : string -> unitval _stop_after : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _keep_docs : unit -> unitval _no_keep_docs : unit -> unitval _keep_locs : unit -> unitval _no_keep_locs : unit -> unitval _linkall : unit -> unitval _noautolink : unit -> unitval _opaque : unit -> unitval _output_obj : unit -> unitval _output_complete_obj : unit -> unitval _plugin : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _runtime_variant : string -> unitval _with_runtime : unit -> unitval _without_runtime : unit -> unitval _short_paths : unit -> unitval _thread : unit -> unitval _verbose : unit -> unitval _where : unit -> unitval _color : string -> unitval _error_style : string -> unitval _match_context_rows : int -> unitval _dtimings : unit -> unitval _dprofile : unit -> unitval _dump_into_file : unit -> unitval _dump_dir : string -> unitval _args : string -> string array val _args0 : string -> string array val _compat_32 : unit -> unitval _custom : unit -> unitval _no_check_prims : unit -> unitval _dllib : string -> unitval _dllpath : string -> unitval _make_runtime : unit -> unitval _vmthread : unit -> unitval _use_runtime : string -> unitval _output_complete_exe : unit -> unitval _dinstr : unit -> unitval _dcamlprimc : unit -> unitval _use_prims : string -> unitMake_bytecomp_options (ocaml.Main_args.Make_bytecomp_options) Up – ocaml » Main_args » Make_bytecomp_optionsModule Main_args.Make_bytecomp_options _ (ocaml.Main_args.Make_bytetop_options._) Up – ocaml » Main_args » Make_bytetop_options » _Parameter Make_bytetop_options._ include Toplevel_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitval _init : string -> unitval _noinit : unit -> unitval _no_version : unit -> unitval _noprompt : unit -> unitval _nopromptcont : unit -> unitval _stdin : unit -> unitval _args : string -> string array val _args0 : string -> string array val _color : string -> unitval _error_style : string -> unitval _eval : string -> unitval _dinstr : unit -> unitMake_bytetop_options (ocaml.Main_args.Make_bytetop_options) Up – ocaml » Main_args » Make_bytetop_optionsModule Main_args.Make_bytetop_options _ (ocaml.Main_args.Make_ocamldoc_options._) Up – ocaml » Main_args » Make_ocamldoc_options » _Parameter Make_ocamldoc_options._ include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _thread : unit -> unitval _verbose : unit -> unitval _vmthread : unit -> unitMake_ocamldoc_options (ocaml.Main_args.Make_ocamldoc_options) Up – ocaml » Main_args » Make_ocamldoc_optionsModule Main_args.Make_ocamldoc_options _ (ocaml.Main_args.Make_optcomp_options._) Up – ocaml » Main_args » Make_optcomp_options » _Parameter Make_optcomp_options._ include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitinclude Compiler_options val _annot : unit -> unitval _binannot : unit -> unitval _cclib : string -> unitval _ccopt : string -> unitval _cmi_file : string -> unitval _config : unit -> unitval _config_var : string -> unitval _for_pack : string -> unitval _stop_after : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _keep_docs : unit -> unitval _no_keep_docs : unit -> unitval _keep_locs : unit -> unitval _no_keep_locs : unit -> unitval _linkall : unit -> unitval _noautolink : unit -> unitval _opaque : unit -> unitval _output_obj : unit -> unitval _output_complete_obj : unit -> unitval _plugin : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _runtime_variant : string -> unitval _with_runtime : unit -> unitval _without_runtime : unit -> unitval _short_paths : unit -> unitval _thread : unit -> unitval _verbose : unit -> unitval _where : unit -> unitval _color : string -> unitval _error_style : string -> unitval _match_context_rows : int -> unitval _dtimings : unit -> unitval _dprofile : unit -> unitval _dump_into_file : unit -> unitval _dump_dir : string -> unitval _args : string -> string array val _args0 : string -> string array include Optcommon_options val _compact : unit -> unitval _inline : string -> unitval _inline_toplevel : string -> unitval _inlining_report : unit -> unitval _dump_pass : string -> unitval _inline_max_depth : string -> unitval _rounds : int -> unitval _inline_max_unroll : string -> unitval _classic_inlining : unit -> unitval _inline_call_cost : string -> unitval _inline_alloc_cost : string -> unitval _inline_prim_cost : string -> unitval _inline_branch_cost : string -> unitval _inline_indirect_cost : string -> unitval _inline_lifting_benefit : string -> unitval _unbox_closures : unit -> unitval _unbox_closures_factor : int -> unitval _inline_branch_factor : string -> unitval _remove_unused_arguments : unit -> unitval _no_unbox_free_vars_of_closures : unit -> unitval _no_unbox_specialised_args : unit -> unitval _insn_sched : unit -> unitval _no_insn_sched : unit -> unitval _linscan : unit -> unitval _no_float_const_prop : unit -> unitval _clambda_checks : unit -> unitval _dflambda : unit -> unitval _drawflambda : unit -> unitval _dflambda_invariants : unit -> unitval _dflambda_no_invariants : unit -> unitval _dflambda_let : int -> unitval _dflambda_verbose : unit -> unitval _drawclambda : unit -> unitval _dclambda : unit -> unitval _dcmm_invariants : unit -> unitval _dcombine : unit -> unitval _dlive : unit -> unitval _dspill : unit -> unitval _dsplit : unit -> unitval _dinterf : unit -> unitval _dprefer : unit -> unitval _dalloc : unit -> unitval _dreload : unit -> unitval _dscheduling : unit -> unitval _dlinear : unit -> unitval _dinterval : unit -> unitval _dstartup : unit -> unitval _nodynlink : unit -> unitval _shared : unit -> unitval _afl_instrument : unit -> unitval _afl_inst_ratio : int -> unitval _function_sections : unit -> unitval _save_ir_after : string -> unitMake_optcomp_options (ocaml.Main_args.Make_optcomp_options) Up – ocaml » Main_args » Make_optcomp_optionsModule Main_args.Make_optcomp_options _ (ocaml.Main_args.Make_opttop_options._) Up – ocaml » Main_args » Make_opttop_options » _Parameter Make_opttop_options._ include Toplevel_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitval _init : string -> unitval _noinit : unit -> unitval _no_version : unit -> unitval _noprompt : unit -> unitval _nopromptcont : unit -> unitval _stdin : unit -> unitval _args : string -> string array val _args0 : string -> string array val _color : string -> unitval _error_style : string -> unitval _eval : string -> unitinclude Optcommon_options val _compact : unit -> unitval _inline : string -> unitval _inline_toplevel : string -> unitval _inlining_report : unit -> unitval _dump_pass : string -> unitval _inline_max_depth : string -> unitval _rounds : int -> unitval _inline_max_unroll : string -> unitval _classic_inlining : unit -> unitval _inline_call_cost : string -> unitval _inline_alloc_cost : string -> unitval _inline_prim_cost : string -> unitval _inline_branch_cost : string -> unitval _inline_indirect_cost : string -> unitval _inline_lifting_benefit : string -> unitval _unbox_closures : unit -> unitval _unbox_closures_factor : int -> unitval _inline_branch_factor : string -> unitval _remove_unused_arguments : unit -> unitval _no_unbox_free_vars_of_closures : unit -> unitval _no_unbox_specialised_args : unit -> unitval _insn_sched : unit -> unitval _no_insn_sched : unit -> unitval _linscan : unit -> unitval _no_float_const_prop : unit -> unitval _clambda_checks : unit -> unitval _dflambda : unit -> unitval _drawflambda : unit -> unitval _dflambda_invariants : unit -> unitval _dflambda_no_invariants : unit -> unitval _dflambda_let : int -> unitval _dflambda_verbose : unit -> unitval _drawclambda : unit -> unitval _dclambda : unit -> unitval _dcmm_invariants : unit -> unitval _dcombine : unit -> unitval _dlive : unit -> unitval _dspill : unit -> unitval _dsplit : unit -> unitval _dinterf : unit -> unitval _dprefer : unit -> unitval _dalloc : unit -> unitval _dreload : unit -> unitval _dscheduling : unit -> unitval _dlinear : unit -> unitval _dinterval : unit -> unitval _dstartup : unit -> unitval _verbose : unit -> unitMake_opttop_options (ocaml.Main_args.Make_opttop_options) Up – ocaml » Main_args » Make_opttop_optionsModule Main_args.Make_opttop_options Main_args (ocaml.Main_args) Up – ocaml » Main_argsoptions_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.
Arg_list (ocaml.Main_args.Arg_list) Up – ocaml » Main_args » Arg_listModule type Main_args.Arg_list Bytecomp_options (ocaml.Main_args.Bytecomp_options) Up – ocaml » Main_args » Bytecomp_optionsModule type Main_args.Bytecomp_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitinclude Compiler_options val _annot : unit -> unitval _binannot : unit -> unitval _cclib : string -> unitval _ccopt : string -> unitval _cmi_file : string -> unitval _config : unit -> unitval _config_var : string -> unitval _for_pack : string -> unitval _stop_after : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _keep_docs : unit -> unitval _no_keep_docs : unit -> unitval _keep_locs : unit -> unitval _no_keep_locs : unit -> unitval _linkall : unit -> unitval _noautolink : unit -> unitval _opaque : unit -> unitval _output_obj : unit -> unitval _output_complete_obj : unit -> unitval _plugin : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _runtime_variant : string -> unitval _with_runtime : unit -> unitval _without_runtime : unit -> unitval _short_paths : unit -> unitval _thread : unit -> unitval _verbose : unit -> unitval _where : unit -> unitval _color : string -> unitval _error_style : string -> unitval _match_context_rows : int -> unitval _dtimings : unit -> unitval _dprofile : unit -> unitval _dump_into_file : unit -> unitval _dump_dir : string -> unitval _args : string -> string array val _args0 : string -> string array val _compat_32 : unit -> unitval _custom : unit -> unitval _no_check_prims : unit -> unitval _dllib : string -> unitval _dllpath : string -> unitval _make_runtime : unit -> unitval _vmthread : unit -> unitval _use_runtime : string -> unitval _output_complete_exe : unit -> unitval _dinstr : unit -> unitval _dcamlprimc : unit -> unitval _use_prims : string -> unitBytetop_options (ocaml.Main_args.Bytetop_options) Up – ocaml » Main_args » Bytetop_optionsModule type Main_args.Bytetop_options include Toplevel_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitval _init : string -> unitval _noinit : unit -> unitval _no_version : unit -> unitval _noprompt : unit -> unitval _nopromptcont : unit -> unitval _stdin : unit -> unitval _args : string -> string array val _args0 : string -> string array val _color : string -> unitval _error_style : string -> unitval _eval : string -> unitval _dinstr : unit -> unitCommon_options (ocaml.Main_args.Common_options) Up – ocaml » Main_args » Common_optionsModule type Main_args.Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitCompiler_options (ocaml.Main_args.Compiler_options) Up – ocaml » Main_args » Compiler_optionsModule type Main_args.Compiler_options val _annot : unit -> unitval _binannot : unit -> unitval _cclib : string -> unitval _ccopt : string -> unitval _cmi_file : string -> unitval _config : unit -> unitval _config_var : string -> unitval _for_pack : string -> unitval _stop_after : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _keep_docs : unit -> unitval _no_keep_docs : unit -> unitval _keep_locs : unit -> unitval _no_keep_locs : unit -> unitval _linkall : unit -> unitval _noautolink : unit -> unitval _opaque : unit -> unitval _output_obj : unit -> unitval _output_complete_obj : unit -> unitval _plugin : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _runtime_variant : string -> unitval _with_runtime : unit -> unitval _without_runtime : unit -> unitval _short_paths : unit -> unitval _thread : unit -> unitval _verbose : unit -> unitval _where : unit -> unitval _color : string -> unitval _error_style : string -> unitval _match_context_rows : int -> unitval _dtimings : unit -> unitval _dprofile : unit -> unitval _dump_into_file : unit -> unitval _dump_dir : string -> unitval _args : string -> string array val _args0 : string -> string array Core_options (ocaml.Main_args.Core_options) Up – ocaml » Main_args » Core_optionsModule type Main_args.Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitOcamldoc_options (ocaml.Main_args.Ocamldoc_options) Up – ocaml » Main_args » Ocamldoc_optionsModule type Main_args.Ocamldoc_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _thread : unit -> unitval _verbose : unit -> unitval _vmthread : unit -> unitOptcommon_options (ocaml.Main_args.Optcommon_options) Up – ocaml » Main_args » Optcommon_optionsModule type Main_args.Optcommon_options val _compact : unit -> unitval _inline : string -> unitval _inline_toplevel : string -> unitval _inlining_report : unit -> unitval _dump_pass : string -> unitval _inline_max_depth : string -> unitval _rounds : int -> unitval _inline_max_unroll : string -> unitval _classic_inlining : unit -> unitval _inline_call_cost : string -> unitval _inline_alloc_cost : string -> unitval _inline_prim_cost : string -> unitval _inline_branch_cost : string -> unitval _inline_indirect_cost : string -> unitval _inline_lifting_benefit : string -> unitval _unbox_closures : unit -> unitval _unbox_closures_factor : int -> unitval _inline_branch_factor : string -> unitval _remove_unused_arguments : unit -> unitval _no_unbox_free_vars_of_closures : unit -> unitval _no_unbox_specialised_args : unit -> unitval _insn_sched : unit -> unitval _no_insn_sched : unit -> unitval _linscan : unit -> unitval _no_float_const_prop : unit -> unitval _clambda_checks : unit -> unitval _dflambda : unit -> unitval _drawflambda : unit -> unitval _dflambda_invariants : unit -> unitval _dflambda_no_invariants : unit -> unitval _dflambda_let : int -> unitval _dflambda_verbose : unit -> unitval _drawclambda : unit -> unitval _dclambda : unit -> unitval _dcmm_invariants : unit -> unitval _dcombine : unit -> unitval _dlive : unit -> unitval _dspill : unit -> unitval _dsplit : unit -> unitval _dinterf : unit -> unitval _dprefer : unit -> unitval _dalloc : unit -> unitval _dreload : unit -> unitval _dscheduling : unit -> unitval _dlinear : unit -> unitval _dinterval : unit -> unitval _dstartup : unit -> unitOptcomp_options (ocaml.Main_args.Optcomp_options) Up – ocaml » Main_args » Optcomp_optionsModule type Main_args.Optcomp_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitinclude Compiler_options val _annot : unit -> unitval _binannot : unit -> unitval _cclib : string -> unitval _ccopt : string -> unitval _cmi_file : string -> unitval _config : unit -> unitval _config_var : string -> unitval _for_pack : string -> unitval _stop_after : string -> unitval _impl : string -> unitval _intf : string -> unitval _intf_suffix : string -> unitval _keep_docs : unit -> unitval _no_keep_docs : unit -> unitval _keep_locs : unit -> unitval _no_keep_locs : unit -> unitval _linkall : unit -> unitval _noautolink : unit -> unitval _opaque : unit -> unitval _output_obj : unit -> unitval _output_complete_obj : unit -> unitval _plugin : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _runtime_variant : string -> unitval _with_runtime : unit -> unitval _without_runtime : unit -> unitval _short_paths : unit -> unitval _thread : unit -> unitval _verbose : unit -> unitval _where : unit -> unitval _color : string -> unitval _error_style : string -> unitval _match_context_rows : int -> unitval _dtimings : unit -> unitval _dprofile : unit -> unitval _dump_into_file : unit -> unitval _dump_dir : string -> unitval _args : string -> string array val _args0 : string -> string array include Optcommon_options val _compact : unit -> unitval _inline : string -> unitval _inline_toplevel : string -> unitval _inlining_report : unit -> unitval _dump_pass : string -> unitval _inline_max_depth : string -> unitval _rounds : int -> unitval _inline_max_unroll : string -> unitval _classic_inlining : unit -> unitval _inline_call_cost : string -> unitval _inline_alloc_cost : string -> unitval _inline_prim_cost : string -> unitval _inline_branch_cost : string -> unitval _inline_indirect_cost : string -> unitval _inline_lifting_benefit : string -> unitval _unbox_closures : unit -> unitval _unbox_closures_factor : int -> unitval _inline_branch_factor : string -> unitval _remove_unused_arguments : unit -> unitval _no_unbox_free_vars_of_closures : unit -> unitval _no_unbox_specialised_args : unit -> unitval _insn_sched : unit -> unitval _no_insn_sched : unit -> unitval _linscan : unit -> unitval _no_float_const_prop : unit -> unitval _clambda_checks : unit -> unitval _dflambda : unit -> unitval _drawflambda : unit -> unitval _dflambda_invariants : unit -> unitval _dflambda_no_invariants : unit -> unitval _dflambda_let : int -> unitval _dflambda_verbose : unit -> unitval _drawclambda : unit -> unitval _dclambda : unit -> unitval _dcmm_invariants : unit -> unitval _dcombine : unit -> unitval _dlive : unit -> unitval _dspill : unit -> unitval _dsplit : unit -> unitval _dinterf : unit -> unitval _dprefer : unit -> unitval _dalloc : unit -> unitval _dreload : unit -> unitval _dscheduling : unit -> unitval _dlinear : unit -> unitval _dinterval : unit -> unitval _dstartup : unit -> unitval _nodynlink : unit -> unitval _shared : unit -> unitval _afl_instrument : unit -> unitval _afl_inst_ratio : int -> unitval _function_sections : unit -> unitval _save_ir_after : string -> unitOpttop_options (ocaml.Main_args.Opttop_options) Up – ocaml » Main_args » Opttop_optionsModule type Main_args.Opttop_options include Toplevel_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitval _init : string -> unitval _noinit : unit -> unitval _no_version : unit -> unitval _noprompt : unit -> unitval _nopromptcont : unit -> unitval _stdin : unit -> unitval _args : string -> string array val _args0 : string -> string array val _color : string -> unitval _error_style : string -> unitval _eval : string -> unitinclude Optcommon_options val _compact : unit -> unitval _inline : string -> unitval _inline_toplevel : string -> unitval _inlining_report : unit -> unitval _dump_pass : string -> unitval _inline_max_depth : string -> unitval _rounds : int -> unitval _inline_max_unroll : string -> unitval _classic_inlining : unit -> unitval _inline_call_cost : string -> unitval _inline_alloc_cost : string -> unitval _inline_prim_cost : string -> unitval _inline_branch_cost : string -> unitval _inline_indirect_cost : string -> unitval _inline_lifting_benefit : string -> unitval _unbox_closures : unit -> unitval _unbox_closures_factor : int -> unitval _inline_branch_factor : string -> unitval _remove_unused_arguments : unit -> unitval _no_unbox_free_vars_of_closures : unit -> unitval _no_unbox_specialised_args : unit -> unitval _insn_sched : unit -> unitval _no_insn_sched : unit -> unitval _linscan : unit -> unitval _no_float_const_prop : unit -> unitval _clambda_checks : unit -> unitval _dflambda : unit -> unitval _drawflambda : unit -> unitval _dflambda_invariants : unit -> unitval _dflambda_no_invariants : unit -> unitval _dflambda_let : int -> unitval _dflambda_verbose : unit -> unitval _drawclambda : unit -> unitval _dclambda : unit -> unitval _dcmm_invariants : unit -> unitval _dcombine : unit -> unitval _dlive : unit -> unitval _dspill : unit -> unitval _dsplit : unit -> unitval _dinterf : unit -> unitval _dprefer : unit -> unitval _dalloc : unit -> unitval _dreload : unit -> unitval _dscheduling : unit -> unitval _dlinear : unit -> unitval _dinterval : unit -> unitval _dstartup : unit -> unitval _verbose : unit -> unitToplevel_options (ocaml.Main_args.Toplevel_options) Up – ocaml » Main_args » Toplevel_optionsModule type Main_args.Toplevel_options include Core_options include Common_options val _absname : unit -> unitval _no_absname : unit -> unitval _alert : string -> unitval _labels : unit -> unitval _alias_deps : unit -> unitval _no_alias_deps : unit -> unitval _app_funct : unit -> unitval _no_app_funct : unit -> unitval _noassert : unit -> unitval _nolabels : unit -> unitval _nostdlib : unit -> unitval _nocwd : unit -> unitval _open : string -> unitval _ppx : string -> unitval _principal : unit -> unitval _no_principal : unit -> unitval _rectypes : unit -> unitval _no_rectypes : unit -> unitval _safer_matching : unit -> unitval _short_paths : unit -> unitval _strict_sequence : unit -> unitval _no_strict_sequence : unit -> unitval _unboxed_types : unit -> unitval _no_unboxed_types : unit -> unitval _version : unit -> unitval anonymous : string -> unitval _nopervasives : unit -> unitval _unsafe : unit -> unitval _warn_error : string -> unitval _warn_help : unit -> unitval _dno_unique_ids : unit -> unitval _dunique_ids : unit -> unitval _dno_locations : unit -> unitval _dlocations : unit -> unitval _dsource : unit -> unitval _dparsetree : unit -> unitval _dtypedtree : unit -> unitval _dshape : unit -> unitval _drawlambda : unit -> unitval _dlambda : unit -> unitval _init : string -> unitval _noinit : unit -> unitval _no_version : unit -> unitval _noprompt : unit -> unitval _nopromptcont : unit -> unitval _stdin : unit -> unitval _args : string -> string array val _args0 : string -> string array val _color : string -> unitval _error_style : string -> unitval _eval : string -> unitMaindriver (ocaml.Maindriver) Up – ocaml » MaindriverMakedepend (ocaml.Makedepend) Up – ocaml » Makedependval main_from_option : unit -> unitMatching (ocaml.Matching) Up – ocaml » MatchingMeta (ocaml.Meta) Up – ocaml » Metaval realloc_global_data : int -> unitval get_section_table : unit -> (string * Stdlib.Obj.t ) listColor (ocaml.Misc.Color) Up – ocaml » Misc » Colortype color = | Black | Red | Green | Yellow | Blue | Magenta | Cyan | White type style = | FG of color | BG of color | Bold | Reset val ansi_of_style_l : style list-> val get_styles : unit -> styles val set_styles : styles -> type setting = | Auto | Always | Never Error_style (ocaml.Misc.Error_style) Up – ocaml » Misc » Error_styletype setting = | Contextual | Short Int_literal_converter (ocaml.Misc.Int_literal_converter) Up – ocaml » Misc » Int_literal_converterModule Misc.Int_literal_converter Convert a string to an integer. Unlike Stdlib.int_of_string, this function accepts the string representation of max_int + 1 and returns min_int in this case.
val int32 : string -> int32val int64 : string -> int64val nativeint : string -> nativeintLikewise, at type nativeint
LongString (ocaml.Misc.LongString) Up – ocaml » Misc » LongStringval get : t -> int -> charval set : t -> int -> char -> unitval blit : t -> int -> t -> int -> int -> unitval blit_string : string -> int -> t -> int -> int -> unitMagic_number (ocaml.Misc.Magic_number) Up – ocaml » Misc » Magic_numberModule Misc.Magic_number a 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.
type native_obj_config = { flambda : bool; } 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.
the native object file configuration of the active/configured compiler.
type 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
type parse_error = | Truncated of string| Not_a_magic_number of 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.
Parses a raw magic number
Read 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
all magic numbers take the same number of bytes
type 'a unexpected = { expected : 'a ; actual : 'a ; } check_current kind info checks that the provided magic info is the current version of kind's magic header.
Provides an explanation of the unexpected_error.
Read 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 -> a user-printable string for a kind, eg. "exec" or "cmo", to use in error messages.
val human_name_of_kind : kind -> a user-meaningful name for a kind, eg. "executable file" or "bytecode object file", to use in error messages.
the current magic number of each kind
the current version of each kind
Mainly for internal usage and testing.
the type of raw magic numbers kinds, such as "Caml1999A" for .cma files
parse a raw kind into a kind
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.
val all_kinds : kind listArray (ocaml.Misc.Stdlib.Array) Up – ocaml » Misc » Stdlib » Arrayval exists2 : ('a -> 'b -> -> 'a array-> 'b array-> Same as Array.exists2 from the standard library.
val for_alli : (int -> 'a -> -> 'a array-> 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.
val all_somes : 'a option-> 'a arrayList (ocaml.Misc.Stdlib.List) Up – ocaml » Misc » Stdlib » Listval compare : ('a -> 'a -> -> 'a t -> 'a t -> The lexicographic order supported by the provided order. There is no constraint on the relative lengths of the lists.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> Returns true if and only if the given lists have the same length and content with respect to the given equality function.
val some_if_all_elements_are_some : 'a optiont -> 'a t 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.
val map2_prefix : ('a -> 'b -> 'c ) -> 'a t -> 'b t -> 'c t 'b t 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.
val split_at : int -> 'a t -> 'a t 'a t 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.
val is_prefix : equal :('a -> 'a -> -> 'a list-> of_ :'a list-> 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_.
type 'a longest_common_prefix_result = private { longest_common_prefix : 'a list first_without_longest_common_prefix : 'a list second_without_longest_common_prefix : 'a list } val find_and_chop_longest_common_prefix :
+ equal :('a -> 'a -> -> first :'a list-> second :'a list-> 'a longest_common_prefix_result Returns 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.
Option (ocaml.Misc.Stdlib.Option) Up – ocaml » Misc » Stdlib » OptionMap (ocaml.Misc.Stdlib.String.Map) Up – ocaml » Misc » Stdlib » String » MapThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Set (ocaml.Misc.Stdlib.String.Set) Up – ocaml » Misc » Stdlib » String » SetThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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, but returns the largest element of the given set.
val max_elt_opt : t -> elt optionSame 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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Tbl (ocaml.Misc.Stdlib.String.Tbl) Up – ocaml » Misc » Stdlib » String » Tblval add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> String (ocaml.Misc.Stdlib.String) Up – ocaml » Misc » Stdlib » Stringinclude module type of Stdlib.String val make : int -> char -> stringmake n c is a string of length n with each index holding the character c.
val init : int -> (int -> char) -> init n f is a string of length n with index i holding the character f i (called in increasing index order).
val length : string -> intlength s is the length (number of bytes/characters) of s.
val get : string -> int -> charget s i is the character at index i in s. This is the same as writing s.[i].
val of_bytes : bytes -> stringReturn a new string that contains the same bytes as the given byte sequence.
val to_bytes : string -> bytesReturn a new byte sequence that contains the same bytes as the given string.
val blit : string -> int -> bytes -> int -> int -> unitSame as Bytes.blit_string which should be preferred.
Note. The Stdlib.(^) binary operator concatenates two strings.
val concat : string -> string list -> concat sep ss concatenates the list of strings ss, inserting the separator string sep between each.
val cat : string -> string -> stringcat s1 s2 concatenates s1 and s2 (s1 ^ s2).
val equal : t -> t -> equal s0 s1 is true if and only if s0 and s1 are character-wise equal.
val compare : t -> t -> compare s0 s1 sorts s0 and s1 in lexicographical order. compare behaves like Stdlib.compare
val starts_with : prefix :string -> string -> boolstarts_with ~prefix s is true if and only if s starts with prefix.
val ends_with : suffix :string -> string -> boolends_with ~suffix s is true if and only if s ends with suffix.
val contains_from : string -> int -> char -> boolcontains_from s start c is true if and only if c appears in s after position start.
val rcontains_from : string -> int -> char -> boolrcontains_from s stop c is true if and only if c appears in s before position stop+1.
val contains : string -> char -> boolval sub : string -> int -> int -> stringsub s pos len is a string of length len, containing the substring of s that starts at position pos and has length len.
val split_on_char : char -> string -> string list 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:
The list is not empty. Concatenating its elements using sep as a separator returns a string equal to the input (concat (make 1 sep)
+ (split_on_char sep s) = s). No string in the result contains the sep character. val map : (char -> char) -> string -> stringmap f s is the string resulting from applying f to all the characters of s in increasing order.
val mapi : (int -> char -> char) -> string -> stringmapi f s is like mapf.
val fold_left : ('acc -> char -> 'acc ) -> 'acc -> string -> 'acc 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.
val fold_right : (char -> 'acc -> 'acc ) -> string -> 'acc -> 'acc 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.
val exists : (char -> bool) -> string -> boolexists p s checks if at least one character of s satisfies the predicate p.
val trim : string -> stringtrim s is s without leading and trailing whitespace. Whitespace characters are: ' ', '\x0C' (form feed), '\n', '\r', and '\t'.
val escaped : string -> stringescaped 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).
val uppercase_ascii : string -> stringuppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.
val lowercase_ascii : string -> stringlowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.
val capitalize_ascii : string -> stringcapitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.
val uncapitalize_ascii : string -> stringuncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.
val iter : (char -> unit) -> string -> unititer 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]; ().
val iteri : (int -> char -> unit) -> string -> unititeri is like iter
val index_from : string -> int -> char -> intindex_from s i c is the index of the first occurrence of c in s after position i.
val index_from_opt : string -> int -> char -> int option index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).
val rindex_from : string -> int -> char -> intrindex_from s i c is the index of the last occurrence of c in s before position i+1.
val rindex_from_opt : string -> int -> char -> int option rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).
val index : string -> char -> intval index_opt : string -> char -> int option val rindex : string -> char -> intval rindex_opt : string -> char -> int option 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
of_seq s is a string made of the sequence's characters.
get_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val is_valid_utf_8 : t -> is_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
get_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val is_valid_utf_16be : t -> is_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
get_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val is_valid_utf_16le : t -> is_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
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.
val get_uint8 : string -> int -> intget_uint8 b i is b's unsigned 8-bit integer starting at character index i.
val get_int8 : string -> int -> intget_int8 b i is b's signed 8-bit integer starting at character index i.
val get_uint16_ne : string -> int -> intget_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.
val get_uint16_be : string -> int -> intget_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.
val get_uint16_le : string -> int -> intget_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.
val get_int16_ne : string -> int -> intget_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.
val get_int16_be : string -> int -> intget_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.
val get_int16_le : string -> int -> intget_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.
val get_int32_ne : string -> int -> int32get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.
An unseeded hash function for strings, with the same output value as Hashtbl.hash. This function allows this module to be passed as argument to the functor Hashtbl.Make.
val seeded_hash : int -> t -> A seeded hash function for strings, with the same output value as Hashtbl.seeded_hash. This function allows this module to be passed as argument to the functor Hashtbl.MakeSeeded.
val get_int32_be : string -> int -> int32get_int32_be b i is b's big-endian 32-bit integer starting at character index i.
val get_int32_le : string -> int -> int32get_int32_le b i is b's little-endian 32-bit integer starting at character index i.
val get_int64_ne : string -> int -> int64get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.
val get_int64_be : string -> int -> int64get_int64_be b i is b's big-endian 64-bit integer starting at character index i.
val get_int64_le : string -> int -> int64get_int64_le b i is b's little-endian 64-bit integer starting at character index i.
val for_all : (char -> bool) -> t -> Stdlib (ocaml.Misc.Stdlib) Up – ocaml » Misc » Stdlibmodule List : sig ... end module Array : sig ... end val compare : 'a -> 'a -> Misc (ocaml.Misc) Up – ocaml » Miscval fatal_error : string -> 'a Raise the Fatal_error exception with the given string.
Format the arguments according to the given format string and raise Fatal_error with the resulting string.
val try_finally :
+ ?always :(unit -> unit) -> ?exceptionally :(unit -> unit) -> (unit -> 'a ) -> 'a try_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.
val reraise_preserving_backtrace : exn -> (unit -> unit) -> 'a reraise_preserving_backtrace e f is (f (); raise e) except that the current backtrace is preserved, even if f uses exceptions internally.
val map_end : ('a -> 'b ) -> 'a list-> 'b list-> 'b listmap_end f l t is map f l @ t, just more efficient.
val map_left_right : ('a -> 'b ) -> 'a list-> 'b listLike List.map, with guaranteed left-to-right evaluation order
val for_all2 : ('a -> 'b -> -> 'a list-> 'b list-> Same as List.for_all but for a binary predicate. In addition, this for_all2 never fails: given two lists with different lengths, it returns false.
val replicate_list : 'a -> int -> 'a listreplicate_list elem n is the list with n elements all identical to elem.
val list_remove : 'a -> 'a list-> 'a listlist_remove x l returns a copy of l with the first element equal to x removed.
val split_last : 'a list-> 'a list'a Return the last element and the other elements of the given list.
Create a hashtable with the given initial size and fills it with the given bindings.
val find_in_path : string list -> string -> stringSearch a file in a list of directories.
val find_in_path_rel : string list -> string -> stringSearch a relative file in a list of directories.
val find_in_path_uncap : string list -> string -> stringSame, but search also for uncapitalized name, i.e. if name is Foo.ml, allow /path/Foo.ml and /path/foo.ml to match.
val remove_file : string -> unitDelete the given file if it exists and is a regular file. Does nothing for other kinds of files. Never raises an error.
val expand_directory : string -> string -> stringexpand_directory alt file eventually expands a + at the beginning of file into alt (an alternate root directory)
val split_path_contents : ?sep :char -> string -> string list split_path_contents ?sep s interprets s as the value of a "PATH"-like variable and returns the corresponding list of directories. s is split using the platform-specific delimiter, or ~sep if it is passed.
Returns the empty list if s is empty.
copy_file ic oc reads the contents of file ic and copies them to oc. It stops when encountering EOF on ic.
copy_file_chunk ic oc n reads n bytes from ic and copies them to oc. It raises End_of_file when encountering EOF on ic.
string_of_file ic reads the contents of file ic and copies them to a string. It stops when encountering EOF on ic.
val output_to_file_via_temporary :
+ ?mode :open_flag list-> string ->
+ (string -> out_channel -> 'a ) -> 'a Produce output in temporary file, then rename it (as atomically as possible) to the desired output file name. output_to_file_via_temporary filename fn opens a temporary file which is passed to fn (name + output channel). When fn returns, the channel is closed and the temporary file is renamed to filename.
val protect_writing_to_file : filename :string -> f :(out_channel -> 'a ) -> 'a Open 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.
val concat_null_terminated : string list -> concat_null_terminated [x1;x2; ... xn] is x1 ^ "\000" ^ x2 ^ "\000" ^ ... ^ xn ^ "\000"
val split_null_terminated : string -> string list split_null_terminated s is similar String.split_on_char '\000' but ignores the trailing separator, if any
val chop_extensions : string -> stringReturn the given file name without its extensions. The extensions is the longest suffix starting with a period and not including a directory separator, .xyz.uvw for instance.
Return the given name if it does not contain an extension.
log2 n returns s such that n = 1 lsl s if n is a power of 2
val align : int -> int -> intalign n a rounds n upwards to a multiple of a (a power of 2).
val no_overflow_add : int -> int -> boolno_overflow_add n1 n2 returns true if the computation of n1 + n2 does not overflow.
val no_overflow_sub : int -> int -> boolno_overflow_sub n1 n2 returns true if the computation of n1 - n2 does not overflow.
val no_overflow_mul : int -> int -> boolno_overflow_mul n1 n2 returns true if the computation of n1 * n2 does not overflow.
val no_overflow_lsl : int -> int -> boolno_overflow_lsl n k returns true if the computation of n lsl k does not overflow.
val find_first_mono : (int -> bool) -> find_first_mono p takes an integer predicate p : int -> bool that we assume: 1. is monotonic on natural numbers: if a <= b then p a implies p b, 2. is satisfied for some natural numbers in range 0; max_int (this is equivalent to: p max_int = true).
find_first_mono p is the smallest natural number N that satisfies p, computed in O(log(N)) calls to p.
Our implementation supports two cases where the preconditions on p are not respected:
If p is always false, we silently return max_int instead of looping or crashing. If p is non-monotonic but eventually true, we return some satisfying value. val search_substring : string -> string -> int -> intsearch_substring pat str start returns the position of the first occurrence of string pat in string str. Search starts at offset start in str. Raise Not_found if pat does not occur.
val replace_substring : before :string -> after :string -> string -> stringreplace_substring ~before ~after str replaces all occurrences of before with after in str and returns the resulting string.
val rev_split_words : string -> string list rev_split_words s splits s in blank-separated words, and returns the list of words in reverse order.
val cut_at : string -> char -> string * stringString.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
val ordinal_suffix : int -> stringordinal_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.
val normalise_eol : string -> stringnormalise_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)
val delete_eol_spaces : string -> stringdelete_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.
protect_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.
val get_ref : 'a listref -> 'a listget_ref lr returns the content of the list reference lr and reset its content to the empty list.
val set_or_ignore : ('a -> 'b option -> 'b optionref -> 'a -> set_or_ignore f opt x sets opt to f x if it returns Some _, or leaves it unmodified if it returns None.
val fst3 : ('a * 'b * 'c ) -> 'a val snd3 : ('a * 'b * 'c ) -> 'b val thd3 : ('a * 'b * 'c ) -> 'c val fst4 : ('a * 'b * 'c * 'd ) -> 'a val snd4 : ('a * 'b * 'c * 'd ) -> 'b val thd4 : ('a * 'b * 'c * 'd ) -> 'c val for4 : ('a * 'b * 'c * 'd ) -> 'd ``Long strings'' are mutable arrays of characters that are not limited in length to Sys.max_string_length.
val edit_distance : string -> string -> int -> int option edit_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.
val spellcheck : string list -> string -> string list 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.
did_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.
module Color : sig ... end print_if ppf flag fmt x prints x with fmt on ppf if b is true.
val pp_two_columns :
+ ?sep :string -> ?max_lines :int -> Stdlib.Format.formatter -> (string * string) list-> pp_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 show_config_and_exit : unit -> unitDisplay the values of all compiler configuration variables from module Config, then exit the program with code 0.
val show_config_variable_and_exit : string -> unitDisplay the value of the given configuration variable, then exit the program with code 0.
Build maps cause the compiler to normalize file names embedded in object files, thus leading to more reproducible builds.
Returns the map encoded in the BUILD_PATH_PREFIX_MAP environment variable.
val debug_prefix_map_flags : unit -> string list Returns the list of --debug-prefix-map flags to be passed to the assembler, built from the BUILD_PATH_PREFIX_MAP environment variable.
a 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.
Mtype (ocaml.Mtype) Up – ocaml » MtypeMap (ocaml.Mutable_variable.Map) Up – ocaml » Mutable_variable » MapModule Mutable_variable.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Mutable_variable.Set) Up – ocaml » Mutable_variable » SetModule Mutable_variable.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Mutable_variable.T) Up – ocaml » Mutable_variable » TModule Mutable_variable.T include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Mutable_variable.Tbl) Up – ocaml » Mutable_variable » TblModule Mutable_variable.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Mutable_variable (ocaml.Mutable_variable) Up – ocaml » Mutable_variableinclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val create_with_same_name_as_ident : Ident.t -> t val unique_name : t -> Map (ocaml.Numbers.Float.Map) Up – ocaml » Numbers » Float » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Numbers.Float.Set) Up – ocaml » Numbers » Float » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Numbers.Float.T) Up – ocaml » Numbers » Float » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Numbers.Float.Tbl) Up – ocaml » Numbers » Float » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Float (ocaml.Numbers.Float) Up – ocaml » Numbers » Floatinclude Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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 (ocaml.Numbers.Int.Map) Up – ocaml » Numbers » Int » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Numbers.Int.Set) Up – ocaml » Numbers » Int » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Numbers.Int.T) Up – ocaml » Numbers » Int » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Numbers.Int.Tbl) Up – ocaml » Numbers » Int » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Int (ocaml.Numbers.Int) Up – ocaml » Numbers » Intinclude Identifiable.S with type t = intinclude Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val zero_to_n : int -> Set.t zero_to_n n is the set of numbers {0, ..., n} (inclusive).
val to_string : int -> stringInt16 (ocaml.Numbers.Int16) Up – ocaml » Numbers » Int16val of_int_exn : int -> t Int8 (ocaml.Numbers.Int8) Up – ocaml » Numbers » Int8val of_int_exn : int -> t Numbers (ocaml.Numbers) Up – ocaml » NumbersModule Numbers Modules about numbers, some of which satisfy Identifiable.S
Warning: this module is unstable and part of compiler-libs .
module Int8 : sig ... end module Int16 : sig ... end Odoc (ocaml.Odoc) Up – ocaml » Odoc
diff --git a/ocaml/Odoc_analyse/index.html b/ocaml/Odoc_analyse/index.html
new file mode 100644
index 00000000..9f754547
--- /dev/null
+++ b/ocaml/Odoc_analyse/index.html
@@ -0,0 +1,5 @@
+
+Odoc_analyse (ocaml.Odoc_analyse) Up – ocaml » Odoc_analyseOdoc_args (ocaml.Odoc_args) Up – ocaml » Odoc_args_ (ocaml.Odoc_ast.Analyser._) Up – ocaml » Odoc_ast » Analyser » _val blank_line_outside_simple : string -> string -> bool
Analyser (ocaml.Odoc_ast.Analyser) Up – ocaml » Odoc_ast » AnalyserTypedtree_search (ocaml.Odoc_ast.Typedtree_search) Up – ocaml » Odoc_ast » Typedtree_searchModule Odoc_ast.Typedtree_search Odoc_ast (ocaml.Odoc_ast) Up – ocaml » Odoc_astOdoc_class (ocaml.Odoc_class) Up – ocaml » Odoc_classand class_apply = { capp_name : Name.t ; mutable capp_class : t_class optioncapp_params : Types.type_expr list capp_params_code : string list ; }
val class_update_parameters_text : t_class ->
Basic_info_retriever (ocaml.Odoc_comments.Basic_info_retriever) Up – ocaml » Odoc_comments » Basic_info_retrieverModule Odoc_comments.Basic_info_retriever val blank_line_outside_simple : string -> string -> bool
Odoc_comments (ocaml.Odoc_comments) Up – ocaml » Odoc_commentsval simple_blank : stringmodule type Texter = sig ... end
Texter (ocaml.Odoc_comments.Texter) Up – ocaml » Odoc_comments » TexterModule type Odoc_comments.Texter Odoc_comments_global (ocaml.Odoc_comments_global) Up – ocaml » Odoc_comments_globalModule Odoc_comments_global val authors : string list ref val version : string option ref val sees : string list ref val since : string option ref val before : (string * string) listref val deprecated : string option ref val params : (string * string) listref val raised_exceptions : (string * string) listref val return_value : string option ref val customs : (string * string) listref Odoc_config (ocaml.Odoc_config) Up – ocaml » Odoc_configval custom_generators_path : stringval print_warnings : bool ref Odoc_cross (ocaml.Odoc_cross) Up – ocaml » Odoc_crossOdoc_dag2html (ocaml.Odoc_dag2html) Up – ocaml » Odoc_dag2htmltype !'a dag = { mutable dag : 'a node } and !'a node = { mutable pare : idag listvalu : 'a ; mutable chil : idag list} val html_of_dag : string dag -> Odoc_dep (ocaml.Odoc_dep) Up – ocaml » Odoc_depdot (ocaml.Odoc_dot.Generator.dot) Up – ocaml » Odoc_dot » Generator » dotval mutable colors : string list method get_one_color : string option
Generator (ocaml.Odoc_dot.Generator) Up – ocaml » Odoc_dot » GeneratorModule Odoc_dot.Generator class dot : object ... end Odoc_dot (ocaml.Odoc_dot) Up – ocaml » Odoc_dotval dot_include_all : bool ref val dot_reduce : bool ref val dot_colors : string list ref dot (ocaml.Odoc_dot.Dot_generator.dot) Up – ocaml » Odoc_dot » Dot_generator » dotval mutable colors : string list method get_one_color : string option
Dot_generator (ocaml.Odoc_dot.Dot_generator) Up – ocaml » Odoc_dot » Dot_generatorModule type Odoc_dot.Dot_generator class dot : object ... end Odoc_env (ocaml.Odoc_env) Up – ocaml » Odoc_envOdoc_exception (ocaml.Odoc_exception) Up – ocaml » Odoc_exceptionOdoc_extension (ocaml.Odoc_extension) Up – ocaml » Odoc_extensiongenerator (ocaml.Odoc_gen.Base_generator.generator) Up – ocaml » Odoc_gen » Base_generator » generatorClass Base_generator.generator Base_generator (ocaml.Odoc_gen.Base_generator) Up – ocaml » Odoc_gen » Base_generatorModule Odoc_gen.Base_generator doc_generator (ocaml.Odoc_gen.doc_generator) Up – ocaml » Odoc_gen » doc_generatorClass type Odoc_gen.doc_generator Odoc_gen (ocaml.Odoc_gen) Up – ocaml » Odoc_genmodule type Base = sig ... end generator (ocaml.Odoc_gen.Base.generator) Up – ocaml » Odoc_gen » Base » generatorBase (ocaml.Odoc_gen.Base) Up – ocaml » Odoc_gen » BaseModule type Odoc_gen.Base generator (ocaml.Odoc_gen.Base_functor._.generator) Up – ocaml » Odoc_gen » Base_functor » _ » generator_ (ocaml.Odoc_gen.Base_functor._) Up – ocaml » Odoc_gen » Base_functor » _generator (ocaml.Odoc_gen.Base_functor.generator) Up – ocaml » Odoc_gen » Base_functor » generatorClass Base_functor.generator Base_functor (ocaml.Odoc_gen.Base_functor) Up – ocaml » Odoc_gen » Base_functorModule type Odoc_gen.Base_functor dot (ocaml.Odoc_gen.Dot_functor._.dot) Up – ocaml » Odoc_gen » Dot_functor » _ » dotval mutable colors : string list method get_one_color : string option
_ (ocaml.Odoc_gen.Dot_functor._) Up – ocaml » Odoc_gen » Dot_functor » _class dot : object ... end dot (ocaml.Odoc_gen.Dot_functor.dot) Up – ocaml » Odoc_gen » Dot_functor » dotval mutable colors : string list method get_one_color : string option
Dot_functor (ocaml.Odoc_gen.Dot_functor) Up – ocaml » Odoc_gen » Dot_functorModule type Odoc_gen.Dot_functor class dot : object ... end html (ocaml.Odoc_gen.Html_functor._.html) Up – ocaml » Odoc_gen » Html_functor » _ » htmlval mutable default_style_options : string list val mutable doctype : string
val mutable style : stringval mutable style_file : stringval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod character_encoding : Buffer.t -> method constructor : string -> stringmethod create_title_label : (int * string option * Odoc_info.text ) -> method escape : string -> stringmethod generate_elements : ('a option-> 'a option-> 'a -> -> 'a list-> method generate_elements_index : ?strip_libname :bool -> 'a list-> ('a -> Odoc_info.Name.t ) -> ('a -> Odoc_info.info option -> ('a -> -> string ->
+ string ->
+ unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Index_list : Buffer.t -> method html_of_Latex : Buffer.t -> string -> unitmethod html_of_Newline : Buffer.t -> method html_of_Raw : Buffer.t -> string -> unitmethod html_of_Target : Buffer.t -> target :string -> code :string -> method html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_author_list : Buffer.t -> string list ->
method html_of_code : Buffer.t -> ?with_pre :bool -> string -> unit
method html_of_since_opt : Buffer.t -> string option -> method html_of_version_opt : Buffer.t -> string option -> method index_attributes : stringmethod index_class_types : stringmethod index_classes : stringmethod index_exceptions : stringmethod index_extensions : stringmethod index_methods : stringmethod index_module_types : stringmethod index_modules : stringmethod index_prefix : stringmethod index_types : stringmethod index_values : stringmethod keep_alpha_num : string -> stringmethod keyword : string -> stringmethod private output_code : ?with_pre :bool -> Odoc_info.Name.t -> string ->
+ string ->
+ unit
_ (ocaml.Odoc_gen.Html_functor._) Up – ocaml » Odoc_gen » Html_functor » _class html : object ... end html (ocaml.Odoc_gen.Html_functor.html) Up – ocaml » Odoc_gen » Html_functor » htmlval mutable default_style_options : string list val mutable doctype : string
val mutable style : stringval mutable style_file : stringval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod character_encoding : Buffer.t -> method constructor : string -> stringmethod create_title_label : (int * string option * Odoc_info.text ) -> method escape : string -> stringmethod generate_elements : ('a option-> 'a option-> 'a -> -> 'a list-> method generate_elements_index : ?strip_libname :bool -> 'a list-> ('a -> Odoc_info.Name.t ) -> ('a -> Odoc_info.info option -> ('a -> -> string ->
+ string ->
+ unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Index_list : Buffer.t -> method html_of_Latex : Buffer.t -> string -> unitmethod html_of_Newline : Buffer.t -> method html_of_Raw : Buffer.t -> string -> unitmethod html_of_Target : Buffer.t -> target :string -> code :string -> method html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_author_list : Buffer.t -> string list ->
method html_of_code : Buffer.t -> ?with_pre :bool -> string -> unit
method html_of_since_opt : Buffer.t -> string option -> method html_of_version_opt : Buffer.t -> string option -> method index_attributes : stringmethod index_class_types : stringmethod index_classes : stringmethod index_exceptions : stringmethod index_extensions : stringmethod index_methods : stringmethod index_module_types : stringmethod index_modules : stringmethod index_prefix : stringmethod index_types : stringmethod index_values : stringmethod keep_alpha_num : string -> stringmethod keyword : string -> stringmethod private output_code : ?with_pre :bool -> Odoc_info.Name.t -> string ->
+ string ->
+ unit
Html_functor (ocaml.Odoc_gen.Html_functor) Up – ocaml » Odoc_gen » Html_functorModule type Odoc_gen.Html_functor class html : object ... end latex (ocaml.Odoc_gen.Latex_functor._.latex) Up – ocaml » Odoc_gen » Latex_functor » _ » latexval subst_strings_code : (Str.regexp * string) listval subst_strings_simple : (Str.regexp * string) list
method escape : string -> stringmethod escape_code : string -> stringmethod escape_simple : string -> stringmethod generate_style_file : unit
method latex_of_Target : Format.formatter -> target :string -> code :string -> method make_label : string -> stringmethod make_ref : string -> stringmethod section_style : int -> string -> stringmethod subst : (Str.regexp * string) list-> string -> string_ (ocaml.Odoc_gen.Latex_functor._) Up – ocaml » Odoc_gen » Latex_functor » _Parameter Latex_functor._ class latex : object ... end latex (ocaml.Odoc_gen.Latex_functor.latex) Up – ocaml » Odoc_gen » Latex_functor » latexClass Latex_functor.latex val subst_strings_code : (Str.regexp * string) listval subst_strings_simple : (Str.regexp * string) list
method escape : string -> stringmethod escape_code : string -> stringmethod escape_simple : string -> stringmethod generate_style_file : unit
method latex_of_Target : Format.formatter -> target :string -> code :string -> method make_label : string -> stringmethod make_ref : string -> stringmethod section_style : int -> string -> stringmethod subst : (Str.regexp * string) list-> string -> stringLatex_functor (ocaml.Odoc_gen.Latex_functor) Up – ocaml » Odoc_gen » Latex_functorModule type Odoc_gen.Latex_functor class latex : object ... end man (ocaml.Odoc_gen.Man_functor._.man) Up – ocaml » Odoc_gen » Man_functor » _ » manval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod escape : string -> string
method man_of_Target : Buffer.t -> target :string -> code :string ->
method man_of_code : Buffer.t -> string -> unit
method remove_newlines : string -> stringmethod str_man_of_author_list : string list -> method str_man_of_custom : (string * Odoc_info.text ) list-> string list method str_man_of_raised_exceptions : (string * Odoc_info.text ) list-> method str_man_of_since_opt : string option -> method str_man_of_version_opt : string option -> _ (ocaml.Odoc_gen.Man_functor._) Up – ocaml » Odoc_gen » Man_functor » _class man : object ... end man (ocaml.Odoc_gen.Man_functor.man) Up – ocaml » Odoc_gen » Man_functor » manval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod escape : string -> string
method man_of_Target : Buffer.t -> target :string -> code :string ->
method man_of_code : Buffer.t -> string -> unit
method remove_newlines : string -> stringmethod str_man_of_author_list : string list -> method str_man_of_custom : (string * Odoc_info.text ) list-> string list method str_man_of_raised_exceptions : (string * Odoc_info.text ) list-> method str_man_of_since_opt : string option -> method str_man_of_version_opt : string option -> Man_functor (ocaml.Odoc_gen.Man_functor) Up – ocaml » Odoc_gen » Man_functorModule type Odoc_gen.Man_functor class man : object ... end texi (ocaml.Odoc_gen.Texi_functor._.texi) Up – ocaml » Odoc_gen » Texi_functor » _ » texival mutable indices_to_build : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ]
+ listmethod do_index : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ] ->
method label : ?no_ :bool -> string -> string_ (ocaml.Odoc_gen.Texi_functor._) Up – ocaml » Odoc_gen » Texi_functor » _class texi : object ... end texi (ocaml.Odoc_gen.Texi_functor.texi) Up – ocaml » Odoc_gen » Texi_functor » texival mutable indices_to_build : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ]
+ listmethod do_index : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ] ->
method label : ?no_ :bool -> string -> stringTexi_functor (ocaml.Odoc_gen.Texi_functor) Up – ocaml » Odoc_gen » Texi_functorModule type Odoc_gen.Texi_functor class texi : object ... end Odoc_global (ocaml.Odoc_global) Up – ocaml » Odoc_globaltype source_file = | Impl_file of string| Intf_file of string| Text_file of stringval include_dirs : string list ref val dump : string option ref val load : string list ref val sort_modules : bool ref val remove_stars : bool ref val inverse_merge_ml_mli : bool ref val filter_with_module_constraints : bool ref val hidden_modules : string list ref val warn_error : bool ref val show_missed_crossref : bool ref val pwarning : string -> unitval out_file : string ref val intro_file : string option ref val title : string option ref val target_dir : string ref val with_index : bool ref
val with_trailer : bool ref val initially_opened_module : string ref val library_namespace : string ref html (ocaml.Odoc_html.Generator.html) Up – ocaml » Odoc_html » Generator » htmlval mutable default_style_options : string list val mutable doctype : string
val mutable style : stringval mutable style_file : stringval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod character_encoding : Buffer.t -> method constructor : string -> stringmethod create_title_label : (int * string option * Odoc_info.text ) -> method escape : string -> stringmethod generate_elements : ('a option-> 'a option-> 'a -> -> 'a list-> method generate_elements_index : ?strip_libname :bool -> 'a list-> ('a -> Odoc_info.Name.t ) -> ('a -> Odoc_info.info option -> ('a -> -> string ->
+ string ->
+ unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Index_list : Buffer.t -> method html_of_Latex : Buffer.t -> string -> unitmethod html_of_Newline : Buffer.t -> method html_of_Raw : Buffer.t -> string -> unitmethod html_of_Target : Buffer.t -> target :string -> code :string -> method html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_author_list : Buffer.t -> string list ->
method html_of_code : Buffer.t -> ?with_pre :bool -> string -> unit
method html_of_since_opt : Buffer.t -> string option -> method html_of_version_opt : Buffer.t -> string option -> method index_attributes : stringmethod index_class_types : stringmethod index_classes : stringmethod index_exceptions : stringmethod index_extensions : stringmethod index_methods : stringmethod index_module_types : stringmethod index_modules : stringmethod index_prefix : stringmethod index_types : stringmethod index_values : stringmethod keep_alpha_num : string -> stringmethod keyword : string -> stringmethod private output_code : ?with_pre :bool -> Odoc_info.Name.t -> string ->
+ string ->
+ unit
Generator (ocaml.Odoc_html.Generator) Up – ocaml » Odoc_html » GeneratorModule Odoc_html.Generator class html : object ... end Naming (ocaml.Odoc_html.Naming) Up – ocaml » Odoc_html » Namingval mark_module_type : stringval mark_type_elt : stringval mark_function : stringval mark_extension : stringval mark_exception : stringval mark_attribute : stringval html_files : string -> string * stringval target : string -> string -> stringval subst_infix_symbols : string -> stringval label_target : string -> stringval file_type_module_complete_target : string -> stringval file_code_module_complete_target : string -> stringval file_type_class_complete_target : string -> stringOdoc_html (ocaml.Odoc_html) Up – ocaml » Odoc_htmlval with_parameter_list : bool ref val css_style : string option ref val index_only : bool ref val colorize_code : bool ref val html_short_functors : bool ref val show_navbar : bool ref html (ocaml.Odoc_html.Html_generator.html) Up – ocaml » Odoc_html » Html_generator » htmlClass Html_generator.html val mutable default_style_options : string list val mutable doctype : string
val mutable style : stringval mutable style_file : stringval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod character_encoding : Buffer.t -> method constructor : string -> stringmethod create_title_label : (int * string option * Odoc_info.text ) -> method escape : string -> stringmethod generate_elements : ('a option-> 'a option-> 'a -> -> 'a list-> method generate_elements_index : ?strip_libname :bool -> 'a list-> ('a -> Odoc_info.Name.t ) -> ('a -> Odoc_info.info option -> ('a -> -> string ->
+ string ->
+ unitmethod html_of_Code : Buffer.t -> string -> unitmethod html_of_CodePre : Buffer.t -> string -> unitmethod html_of_Index_list : Buffer.t -> method html_of_Latex : Buffer.t -> string -> unitmethod html_of_Newline : Buffer.t -> method html_of_Raw : Buffer.t -> string -> unitmethod html_of_Target : Buffer.t -> target :string -> code :string -> method html_of_Verbatim : Buffer.t -> string -> unitmethod html_of_author_list : Buffer.t -> string list ->
method html_of_code : Buffer.t -> ?with_pre :bool -> string -> unit
method html_of_since_opt : Buffer.t -> string option -> method html_of_version_opt : Buffer.t -> string option -> method index_attributes : stringmethod index_class_types : stringmethod index_classes : stringmethod index_exceptions : stringmethod index_extensions : stringmethod index_methods : stringmethod index_module_types : stringmethod index_modules : stringmethod index_prefix : stringmethod index_types : stringmethod index_values : stringmethod keep_alpha_num : string -> stringmethod keyword : string -> stringmethod private output_code : ?with_pre :bool -> Odoc_info.Name.t -> string ->
+ string ->
+ unit
Html_generator (ocaml.Odoc_html.Html_generator) Up – ocaml » Odoc_html » Html_generatorModule type Odoc_html.Html_generator class html : object ... end Class (ocaml.Odoc_info.Class) Up – ocaml » Odoc_info » ClassTo keep the order of elements in a class.
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 optionThe 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 optionThe 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 optionThe 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 listclass_element listAn explicit class structure, used in implementation and interface.
| Class_apply of class_apply Application/alias of a class, used in implementation only.
| Class_constr of class_constr A 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_kind A class definition with a constraint.
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 optionThe target t_class or t_class_type, if we found it.
cta_type_parameters : Types.type_expr list The type parameters. FIXME : use strings?
} Representation of a class type.
Access to the elements of a class.
Access to the list of class attributes.
val class_parameter_text_by_name : t_class -> string -> text optionAccess to the description associated to the given class parameter name.
Access to the methods of a class.
Access to the comments of a class.
Access to the elements of a class type.
Access 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.
Access to the methods of a class type.
Access to the comments of a class type.
Dep (ocaml.Odoc_info.Dep) Up – ocaml » Odoc_info » DepModify the module dependencies of the given list of modules, to get the minimum transitivity kernel.
Return the list of dependencies between the given types, in the form of a list (type name, names of types it depends on).
Exception (ocaml.Odoc_info.Exception) Up – ocaml » Odoc_info » ExceptionUsed when the exception is a rebind of another exception, when we have exception Ex = Target_ex.
Extension (ocaml.Odoc_info.Extension) Up – ocaml » Odoc_info » ExtensionUsed when the extension is a rebind of another extension, when we have extension Xt = Target_xt.
Access to the extensions in a group.
Global (ocaml.Odoc_info.Global) Up – ocaml » Odoc_info » Globalval warn_error : bool ref val out_file : string ref The file used by the generators outputting only one file.
val target_dir : string ref The directory where files have to be generated.
val title : string option ref The optional title to use in the generated documentation.
val intro_file : string option ref The optional file whose content can be used as intro text.
The flag which indicates if we must generate a table of contents.
val with_index : bool ref The flag which indicates if we must generate an index.
The flag which indicates if we must generate a header.
val with_trailer : bool ref The flag which indicates if we must generate a trailer.
Module (ocaml.Odoc_info.Module) Up – ocaml » Odoc_info » ModuleTo 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 optionThe included module or module type, if we found it.
mutable im_info : Odoc_types.info optioncomment 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 optionThe real module or module type if we could associate it.
} 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 ;mutable m_info : info optionInformation 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 listThe 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.
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 optionInformation found in the optional associated comment.
mutable mt_type : Types.module_type optionNone 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 optionThe 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.
Access to the elements of a module.
Access to the submodules of a module.
Access to the module types of a module.
Access to the included modules of a module.
Access to the type extensions of a module.
Access to the exceptions of a module.
Access to the types of a module.
Access to the values of a module.
Access to functional values of a module.
Access to non-functional values of a module.
Access to the classes of a module.
Access to the class types of a module.
The list of classes defined in this module and all its submodules and functors.
val module_is_functor : t_module -> true if the module is functor.
The list of couples (module parameter, optional description).
The list of module comments.
Access to the elements of a module type.
Access to the submodules of a module type.
Access to the module types of a module type.
Access to the included modules of a module type.
Access to the exceptions of a module type.
Access to the types of a module type.
Access to the values of a module type.
Access to functional values of a module type.
Access to non-functional values of a module type.
Access to the classes of a module type.
Access to the class types of a module type.
The list of classes defined in this module type and all its submodules and functors.
true if the module type is functor.
The list of couples (module parameter, optional description).
The list of module comments.
Name (ocaml.Odoc_info.Name) Up – ocaml » Odoc_info » NameAccess to the simple name.
concat t1 t2 returns the concatenation of t1 and t2.
Return the depth of the name, i.e. the number of levels to the root. Example : depth "Toto.Tutu.name" = 3.
val get_relative : t -> t -> t Take two names n1 and n2 = n3.n4 and return n4 if n3=n1 or else n2.
val get_relative_opt : t -> t -> t Take two names n1 and n2 = n3.n4 and return n4 if n3=n1 and n1<>"" or else n2.
Return the name of the 'father' (like dirname for a file name).
Parameter (ocaml.Odoc_info.Parameter) Up – ocaml » Odoc_info » ParameterRepresentation of a simple parameter name
Representation of parameter names. We need it to represent parameter names in tuples. The value Tuple ([], t) stands for an anonymous parameter.
A parameter is just a param_info.
Access to the name as a string. For tuples, parentheses and commas are added.
Access to the complete type.
Access to the list of names ; only one for a simple parameter, or a list for a tuple.
Access to the description of a specific name.
Access to the type of a specific name.
scanner (ocaml.Odoc_info.Scan.scanner) Up – ocaml » Odoc_info » Scan » scannerScan of a type extension
Override this method to perform controls on the extension's type, private and info. This method is called before scanning the extension's constructors.
This method scans the constructors of the given type extension.
Scan 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.
Scan of a comment inside a class.
Override this method to perform controls on the class comment and params. This method is called before scanning the class elements.
This method scans the elements of the given class.
Scan 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.
Scan of a comment inside a class type.
Override this method to perform controls on the class type comment and form. This method is called before scanning the class type elements.
This method scans the elements of the given class type.
Scan 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.
Scan of a comment inside a module.
Override this method to perform controls on the module comment and form. This method is called before scanning the module elements.
This method scans the elements of the given module.
Scan 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.
Scan of a comment inside a module type.
Override this method to perform controls on the module type comment and form. This method is called before scanning the module type elements.
This method scans the elements of the given module type.
Scan 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.
Scan (ocaml.Odoc_info.Scan) Up – ocaml » Odoc_info » ScanSearch (ocaml.Odoc_info.Search) Up – ocaml » Odoc_info » SearchModule Odoc_info.Search Research in elements
The type representing a research result.
Research of the elements whose name matches the given regular expression.
A function to search all the values in a list of modules.
A function to search all the extensions in a list of modules.
A function to search all the exceptions in a list of modules.
A function to search all the types in a list of modules.
A function to search all the class attributes in a list of modules.
A function to search all the class methods in a list of modules.
A function to search all the classes in a list of modules.
A function to search all the class types in a list of modules.
A function to search all the modules in a list of modules.
A function to search all the module types in a list of modules.
Type (ocaml.Odoc_info.Type) Up – ocaml » Odoc_info » TypeDescription of a record type field.
Description of a variant type constructor.
The various kinds of a type.
Representation of a type.
Value (ocaml.Odoc_info.Value) Up – ocaml » Odoc_info » Valuetype t_value = Odoc_value.t_value = { val_name : Name.t ; Complete name of the value.
mutable val_info : info optionInformation found in the optional associated comment.
val_type : Types.type_expr ; val_recursive : bool; true if the value is recursive.
mutable val_parameters : Odoc_parameter.parameter listmutable 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.
Return true if the value is a function, i.e. it has a functional type.
val value_parameter_text_by_name : t_value -> string -> text optionAccess to the description associated to the given parameter name.
Odoc_info (ocaml.Odoc_info) Up – ocaml » Odoc_infotype 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_const The different kinds of element references.
and text_element = Odoc_types.text_element = | Raw of string| Code of stringThe string is source code.
| CodePre of stringThe string is pre-formatted source code.
| 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 Style number, optional label, and text.
| Latex of string| Link of string * text A reference string and the link text.
| Ref of string * ref_kind optiontext 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 text | Subscript of text | Module_list of string list The table of the given modules with their abstract.
| Index_list The links to the various indexes (values, types, ...)
| Custom of string * text | Target of string * string(target, code) : to specify code specific to a target format
and text = text_element list A text is a list of text_element. The order matters.
type see_ref = Odoc_types.see_ref = | See_url of string| See_file of string| See_doc of stringThe different forms of references in @see tags.
exception Text_syntax of int * int * stringRaised when parsing string to build a Odoc_info.text(line, char, string)
The information in a @see tag.
type param = string * text Parameter name and description.
type raised_exception = string * text Raised exception name and description.
type alert = Odoc_types.alert = { alert_name : string; alert_payload : string option ; } type info = Odoc_types.info = { i_desc : text option i_authors : string list ; The list of authors in @author tags.
i_version : string option ; The string in the @version tag.
i_sees : see list 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.
i_alerts : alert list Alerts associated to the same item. Not from special comments.
} Information in a special comment
Location of elements in implementation and interface files.
module Name : sig ... end Representation of element names.
Representation and manipulation of method / function / class / module parameters.
Representation and manipulation of extensions.
Representation and manipulation of exceptions.
module Type : sig ... end Representation and manipulation of types.
module Value : sig ... end Representation and manipulation of values, class attributes and class methods.
module Class : sig ... end Representation and manipulation of classes and class types.
Representation and manipulation of modules and module types.
val reset_type_names : unit -> unitThis 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).
string_of_variance t variance returns the variance and injectivity annotation (e.g "+" for covariance, "-" for contravariance, "!-" for injectivity) if the type t is abstract.
This function returns a string representing a Types.type_expr.
val string_of_type_list : ?par :bool -> string -> Types.type_expr list-> This function returns a string to represent the given list of types, with a given separator.
This function returns a string to represent the list of type parameters for the given type.
This function returns a string to represent the list of type parameters for the given type extension.
This 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 -> This function returns a string representing a Types.module_type.
This function returns a string representing a Types.class_type.
val string_of_text : text -> Get a string from a text.
val string_of_info : info -> Get a string from an info structure.
val first_sentence_of_text : text -> text Return 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.
val first_sentence_and_rest_of_text : text -> text * text 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_no_title_no_list : text -> text Return the given text without any title or list.
concat sep l concats the given list of text l, each separated with the text sep.
val get_titles_in_text : text -> (int * string option * text ) listReturn the list of titles in a text. A title is a title level, an optional label and a text.
val create_index_lists : 'a list-> ('a -> -> 'a listTake 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.
Take a type and remove the option top constructor. This is useful when printing labels, we then remove the top option constructor for optional labels.
Return true if the given label is optional.
Return 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)
val verbose : string -> unitPrint the given string if the verbose mode is activated.
val warning : string -> unitPrint a warning message to stderr. If warnings must be treated as errors, then the error counter is incremented.
val print_warnings : bool ref A flag to indicate whether ocamldoc warnings must be printed or not.
Increment 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.
val apply_opt : ('a -> 'b ) -> 'a option-> 'b optionApply a function to an optional value.
val apply_if_equal : ('a -> 'a ) -> 'a -> 'a -> 'a 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 -> text text_of_string s returns the text structure from the given string.
val text_string_of_text : text -> text_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 -> info info_of_string s parses the given string like a regular ocamldoc comment and return an Odoc_info.info
info_of_comment_file file parses the given file and return an Odoc_info.info
val remove_ending_newline : string -> stringremove_ending_newline s returns s without the optional ending newline.
module Scan : sig ... end Scanning of collected information
Computation of dependencies.
Analysis of the given source files.
Dump of a list of modules into a file.
Load of a list of modules from a file.
latex (ocaml.Odoc_latex.Generator.latex) Up – ocaml » Odoc_latex » Generator » latexval subst_strings_code : (Str.regexp * string) listval subst_strings_simple : (Str.regexp * string) list
method escape : string -> stringmethod escape_code : string -> stringmethod escape_simple : string -> stringmethod generate_style_file : unit
method latex_of_Target : Format.formatter -> target :string -> code :string -> method make_label : string -> stringmethod make_ref : string -> stringmethod section_style : int -> string -> stringmethod subst : (Str.regexp * string) list-> string -> stringGenerator (ocaml.Odoc_latex.Generator) Up – ocaml » Odoc_latex » GeneratorModule Odoc_latex.Generator class latex : object ... end Odoc_latex (ocaml.Odoc_latex) Up – ocaml » Odoc_latexval separate_files : bool ref val latex_titles : (int * string) listref val latex_value_prefix : string ref val latex_type_prefix : string ref val latex_type_elt_prefix : string ref val latex_extension_prefix : string ref val latex_exception_prefix : string ref val latex_module_prefix : string ref val latex_module_type_prefix : string ref val latex_class_prefix : string ref val latex_class_type_prefix : string ref val latex_attribute_prefix : string ref val latex_method_prefix : string ref latex (ocaml.Odoc_latex.Latex_generator.latex) Up – ocaml » Odoc_latex » Latex_generator » latexClass Latex_generator.latex val subst_strings_code : (Str.regexp * string) listval subst_strings_simple : (Str.regexp * string) list
method escape : string -> stringmethod escape_code : string -> stringmethod escape_simple : string -> stringmethod generate_style_file : unit
method latex_of_Target : Format.formatter -> target :string -> code :string -> method make_label : string -> stringmethod make_ref : string -> stringmethod section_style : int -> string -> stringmethod subst : (Str.regexp * string) list-> string -> stringLatex_generator (ocaml.Odoc_latex.Latex_generator) Up – ocaml » Odoc_latex » Latex_generatorModule type Odoc_latex.Latex_generator class latex : object ... end Odoc_latex_style (ocaml.Odoc_latex_style) Up – ocaml » Odoc_latex_styleOdoc_lexer (ocaml.Odoc_lexer) Up – ocaml » Odoc_lexerval line_number : int ref
man (ocaml.Odoc_man.Generator.man) Up – ocaml » Odoc_man » Generator » manval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod escape : string -> string
method man_of_Target : Buffer.t -> target :string -> code :string ->
method man_of_code : Buffer.t -> string -> unit
method remove_newlines : string -> stringmethod str_man_of_author_list : string list -> method str_man_of_custom : (string * Odoc_info.text ) list-> string list method str_man_of_raised_exceptions : (string * Odoc_info.text ) list-> method str_man_of_since_opt : string option -> method str_man_of_version_opt : string option -> Generator (ocaml.Odoc_man.Generator) Up – ocaml » Odoc_man » GeneratorModule Odoc_man.Generator class man : object ... end Odoc_man (ocaml.Odoc_man) Up – ocaml » Odoc_manModule Odoc_man The man pages generator.
val man_suffix : string ref val man_section : string ref man (ocaml.Odoc_man.Man_generator.man) Up – ocaml » Odoc_man » Man_generator » manval mutable tag_functions : (string * (Odoc_info.text -> ) listmethod escape : string -> string
method man_of_Target : Buffer.t -> target :string -> code :string ->
method man_of_code : Buffer.t -> string -> unit
method remove_newlines : string -> stringmethod str_man_of_author_list : string list -> method str_man_of_custom : (string * Odoc_info.text ) list-> string list method str_man_of_raised_exceptions : (string * Odoc_info.text ) list-> method str_man_of_since_opt : string option -> method str_man_of_version_opt : string option -> Man_generator (ocaml.Odoc_man.Man_generator) Up – ocaml » Odoc_man » Man_generatorModule type Odoc_man.Man_generator class man : object ... end Odoc_merge (ocaml.Odoc_merge) Up – ocaml » Odoc_mergeOdoc_messages (ocaml.Odoc_messages) Up – ocaml » Odoc_messagesval config_version : stringval latex_texi_only : stringval html_latex_only : stringval html_latex_texi_only : stringval display_custom_generators_dir : stringval add_load_dir : stringval show_missed_crossref : stringval hide_warnings : stringval colorize_code : stringval html_short_functors : stringval charset : string -> stringval generate_html : stringval generate_latex : stringval generate_texinfo : stringval generate_man : stringval generate_dot : stringval option_not_in_native_code : string -> stringval default_out_file : stringval dot_include_all : stringval default_dot_colors : string list listval default_man_section : stringval default_man_suffix : stringval option_title : stringval option_intro : stringval with_parameter_list : stringval hide_modules : string
val separate_files : stringval latex_title : (int * string) listref -> val default_latex_value_prefix : stringval latex_value_prefix : stringval default_latex_type_prefix : stringval latex_type_prefix : stringval default_latex_type_elt_prefix : stringval latex_type_elt_prefix : stringval default_latex_extension_prefix : stringval latex_extension_prefix : stringval default_latex_exception_prefix : stringval latex_exception_prefix : stringval default_latex_module_prefix : stringval latex_module_prefix : stringval default_latex_module_type_prefix : stringval latex_module_type_prefix : stringval default_latex_class_prefix : stringval latex_class_prefix : stringval default_latex_class_type_prefix : stringval latex_class_type_prefix : stringval default_latex_attribute_prefix : stringval latex_attribute_prefix : stringval default_latex_method_prefix : stringval latex_method_prefix : stringval sort_modules : stringval remove_stars : stringval inverse_merge_ml_mli : stringval no_filter_with_module_constraints : stringval merge_description : char * stringval merge_author : char * stringval merge_version : char * stringval merge_see : char * stringval merge_since : char * stringval merge_before : char * stringval merge_deprecated : char * stringval merge_param : char * stringval merge_raised_exception : char * stringval merge_return_value : char * stringval merge_custom : char * stringval merge_all : char * stringval texinfo_title : (int * (string * string) ) listref -> val info_section : stringval options_can_be : stringval string_of_options_list : (char * string) list-> val merge_options : stringval initially_opened_module : stringval library_namespace : stringval error_location : string -> int -> int -> stringval bad_magic_number : stringval not_a_module_name : string -> stringval load_file_error : string -> string -> stringval errors_occured : int -> stringval text_parse_error : int -> int -> string -> stringval file_not_found_in_paths : string list -> string -> stringval tag_not_handled : string -> stringval should_escape_at_sign : stringval not_a_valid_tag : string -> stringval fun_without_param : string -> stringval method_without_param : string -> stringval anonymous_parameters : string -> stringval function_colon : string -> stringval implicit_match_in_parameter : stringval unknown_extension : string -> stringval two_implementations : string -> stringval two_interfaces : string -> stringval too_many_module_objects : string -> stringval extension_not_found_in_implementation : string -> string -> stringval exception_not_found_in_implementation : string -> string -> stringval type_not_found_in_implementation : string -> string -> stringval module_not_found_in_implementation : string -> string -> stringval value_not_found_in_implementation : string -> string -> stringval class_not_found_in_implementation : string -> string -> stringval attribute_not_found_in_implementation : string -> string -> stringval method_not_found_in_implementation : string -> string -> stringval different_types : string -> stringval attribute_type_not_found : string -> string -> stringval method_type_not_found : string -> string -> stringval module_not_found : string -> string -> stringval module_type_not_found : string -> string -> stringval value_not_found : string -> string -> stringval extension_not_found : string -> string -> stringval exception_not_found : string -> string -> stringval type_not_found : string -> string -> stringval class_not_found : string -> string -> stringval class_type_not_found : string -> string -> stringval type_not_found_in_typedtree : string -> stringval extension_not_found_in_typedtree : string -> stringval exception_not_found_in_typedtree : string -> stringval module_type_not_found_in_typedtree : string -> stringval module_not_found_in_typedtree : string -> stringval class_not_found_in_typedtree : string -> stringval class_type_not_found_in_typedtree : string -> stringval inherit_classexp_not_found_in_typedtree : int -> stringval attribute_not_found_in_typedtree : string -> stringval method_not_found_in_typedtree : string -> string
val cross_module_not_found : string -> stringval cross_module_type_not_found : string -> stringval cross_module_or_module_type_not_found : string -> stringval cross_class_not_found : string -> stringval cross_class_type_not_found : string -> stringval cross_class_or_class_type_not_found : string -> stringval cross_extension_not_found : string -> stringval cross_exception_not_found : string -> stringval cross_element_not_found : string -> stringval cross_method_not_found : string -> stringval cross_attribute_not_found : string -> stringval cross_section_not_found : string -> stringval cross_value_not_found : string -> stringval cross_type_not_found : string -> stringval cross_recfield_not_found : string -> stringval cross_const_not_found : string -> stringval code_could_be_cross_reference : string -> string -> stringval current_generator_is_not : string -> stringval analysing : string -> stringval cross_referencing : stringval generating_doc : stringval loading : string -> stringval file_generated : string -> stringval file_exists_dont_generate : string -> stringval type_parameters : stringval module_types : stringval documentation : stringval index_of_values : stringval index_of_extensions : stringval index_of_exceptions : stringval index_of_types : stringval index_of_attributes : stringval index_of_methods : stringval index_of_classes : stringval index_of_class_types : stringval index_of_modules : stringval index_of_module_types : stringOdoc_misc (ocaml.Odoc_misc) Up – ocaml » Odoc_miscval no_blanks : string -> stringval split_with_blanks : string -> string list val string_of_author_list : string list -> val string_of_version_opt : string option -> val string_of_since_opt : string option -> val string_of_raised_exceptions : (string * Odoc_types.text ) list-> val apply_opt : ('a -> 'b ) -> 'a option-> 'b optionval string_of_date : ?absolute :bool -> ?hour :bool -> float -> stringval current_date : stringval create_index_lists : 'a list-> ('a -> -> 'a listval remove_duplicates : ('a -> 'a -> -> 'a list-> 'a listval remove_ending_newline : string -> stringval search_string_backward : pat :string -> s :string -> Odoc_module (ocaml.Odoc_module) Up – ocaml » Odoc_moduleand module_alias = { ma_name : Name.t ; mutable ma_module : mmt option}
val module_is_functor : t_module ->
Map (ocaml.Odoc_name.Map) Up – ocaml » Odoc_name » Mapval add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a listt -> 'a listt val update : key -> ('a option-> 'a option -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t val cardinal : 'a t -> val bindings : 'a t -> (key * 'a ) listval min_binding : 'a t -> key * 'a val min_binding_opt : 'a t -> (key * 'a ) optionval max_binding : 'a t -> key * 'a val max_binding_opt : 'a t -> (key * 'a ) optionval choose : 'a t -> key * 'a val choose_opt : 'a t -> (key * 'a ) optionval find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a optionval find_first : (key -> -> 'a t -> key * 'a val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionval find_last : (key -> -> 'a t -> key * 'a val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionval iter : (key -> 'a -> -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val map : ('a -> 'b ) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t val filter : (key -> 'a -> -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t val partition : (key -> 'a -> -> 'a t -> 'a t 'a t val split : key -> 'a t -> 'a t 'a option'a t val is_empty : 'a t -> val mem : key -> 'a t -> val equal : ('a -> 'a -> -> 'a t -> 'a t -> val compare : ('a -> 'a -> -> 'a t -> 'a t -> val for_all : (key -> 'a -> -> 'a t -> val exists : (key -> 'a -> -> 'a t -> val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t Odoc_name (ocaml.Odoc_name) Up – ocaml » Odoc_nameval parens_if_infix : t -> t val normalize_name : t -> t val prefix : t -> t -> val alias_unprefix : t -> t -> t val get_relative : t -> t -> t val get_relative_opt : t -> t -> t val get_relative_raw : t -> t -> t val hide_given_modules : t list-> t -> t val qualified : t -> Odoc_ocamlhtml (ocaml.Odoc_ocamlhtml) Up – ocaml » Odoc_ocamlhtmlval escape_base : string -> string
Odoc_parameter (ocaml.Odoc_parameter) Up – ocaml » Odoc_parameterTypes
Representation of a simple parameter name
type param_info = | Simple_name of simple_name | Tuple of param_info listTypes.type_expr Representation of parameter names. We need it to represent parameter names in tuples. The value Tuple ([], t) stands for an anonymous parameter.
A parameter is just a param_info.
Functions
access to the name as a string. For tuples, parentheses and commas are added.
access to the complete type
val update_parameter_text :
+ (string -> Odoc_types.text option -> parameter -> Update the text of a parameter using a function returning the optional text associated to a parameter name.
access to the description of a specific name.
access to the list of names ; only one for a simple parameter, or a list for tuples.
access to the type of a specific name.
access to the optional description of a parameter name from an optional info structure.
Odoc_parser (ocaml.Odoc_parser) Up – ocaml » Odoc_parsertype token = | Description of string * string option | See_url of string| See_file of string| See_doc of string| T_PARAM | T_AUTHOR | T_VERSION | T_SEE | T_SINCE | T_BEFORE | T_DEPRECATED | T_RAISES | T_RETURN | T_CUSTOM of string| EOF | Desc of stringOdoc_print (ocaml.Odoc_print) Up – ocaml » Odoc_printval string_of_module_type :
+ ?code :string -> ?complete :bool -> Types.module_type -> scanner (ocaml.Odoc_scan.scanner) Up – ocaml » Odoc_scan » scannerOdoc_scan (ocaml.Odoc_scan) Up – ocaml » Odoc_scanP_name (ocaml.Odoc_search.P_name) Up – ocaml » Odoc_search » P_nameModule Odoc_search.P_name P (ocaml.Odoc_search.Search.P) Up – ocaml » Odoc_search » Search » Pval p_section : string -> t -> Search (ocaml.Odoc_search.Search) Up – ocaml » Odoc_search » SearchModule Odoc_search.Search Search_by_name (ocaml.Odoc_search.Search_by_name) Up – ocaml » Odoc_search » Search_by_nameModule Odoc_search.Search_by_name Odoc_search (ocaml.Odoc_search) Up – ocaml » Odoc_searchPredicates (ocaml.Odoc_search.Predicates) Up – ocaml » Odoc_search » PredicatesModule type Odoc_search.Predicates val p_section : string -> t -> Odoc_see_lexer (ocaml.Odoc_see_lexer) Up – ocaml » Odoc_see_lexer_ (ocaml.Odoc_sig.Analyser._) Up – ocaml » Odoc_sig » Analyser » _val blank_line_outside_simple : string -> string -> bool
Analyser (ocaml.Odoc_sig.Analyser) Up – ocaml » Odoc_sig » Analyserval file_name : string ref val get_string_of_file : int -> int -> stringval prepare_file : string -> string -> unit
Signature_search (ocaml.Odoc_sig.Signature_search) Up – ocaml » Odoc_sig » Signature_searchModule Odoc_sig.Signature_search Odoc_sig (ocaml.Odoc_sig) Up – ocaml » Odoc_sigInfo_retriever (ocaml.Odoc_sig.Info_retriever) Up – ocaml » Odoc_sig » Info_retrieverModule type Odoc_sig.Info_retriever val blank_line_outside_simple : string -> string -> bool
Odoc_str (ocaml.Odoc_str) Up – ocaml » Odoc_strval string_of_type_list : ?par :bool -> string -> Types.type_expr list-> Odoc_test (ocaml.Odoc_test) Up – ocaml » Odoc_test
diff --git a/ocaml/Odoc_texi/Generator/class-texi/index.html b/ocaml/Odoc_texi/Generator/class-texi/index.html
new file mode 100644
index 00000000..2b346595
--- /dev/null
+++ b/ocaml/Odoc_texi/Generator/class-texi/index.html
@@ -0,0 +1,97 @@
+
+texi (ocaml.Odoc_texi.Generator.texi) Up – ocaml » Odoc_texi » Generator » texival mutable indices_to_build : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ]
+ listmethod do_index : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ] ->
method label : ?no_ :bool -> string -> stringmethod scan_for_index : subparts -> Generator (ocaml.Odoc_texi.Generator) Up – ocaml » Odoc_texi » GeneratorModule Odoc_texi.Generator class texi : object ... end Odoc_texi (ocaml.Odoc_texi) Up – ocaml » Odoc_texival info_section : string ref val info_entry : string list ref val titles_and_headings : (int * (string * string) ) listref type indices = [ | `Class | `Class_att | `Class_type | `Exception | `Extension | `Method | `Module | `Module_type | `Type | `Value ] texi (ocaml.Odoc_texi.Texi_generator.texi) Up – ocaml » Odoc_texi » Texi_generator » texiClass Texi_generator.texi val mutable indices_to_build : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ]
+ listmethod do_index : [ `Class
+ | `Class_att
+ | `Class_type
+ | `Exception
+ | `Extension
+ | `Method
+ | `Module
+ | `Module_type
+ | `Type
+ | `Value ] ->
method label : ?no_ :bool -> string -> stringmethod scan_for_index : subparts -> Texi_generator (ocaml.Odoc_texi.Texi_generator) Up – ocaml » Odoc_texi » Texi_generatorModule type Odoc_texi.Texi_generator class texi : object ... end Texter (ocaml.Odoc_text.Texter) Up – ocaml » Odoc_text » TexterOdoc_text (ocaml.Odoc_text) Up – ocaml » Odoc_textexception Text_syntax of int * int * stringOdoc_text_lexer (ocaml.Odoc_text_lexer) Up – ocaml » Odoc_text_lexerval line_number : int ref val char_number : int ref Odoc_text_parser (ocaml.Odoc_text_parser) Up – ocaml » Odoc_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 stringto_text (ocaml.Odoc_to_text.to_text) Up – ocaml » Odoc_to_text » to_textClass Odoc_to_text.to_text method virtual label : ?no_ :bool -> string -> stringOdoc_to_text (ocaml.Odoc_to_text) Up – ocaml » Odoc_to_textModule Odoc_to_text Text generation.
class virtual to_text : object ... end Odoc_type (ocaml.Odoc_type) Up – ocaml » Odoc_typeThis module has an implementation although it declares only types. This is because other modules use the let module construct or access it so it is needed as a real module.
Description of a record type field.
Description of a variant type constructor.
Representation of a type.
Odoc_types (ocaml.Odoc_types) Up – ocaml » 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_const and 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 optiontext option| Superscript of text | Subscript of text | Module_list of string list | Index_list | Custom of string * text | Target of string * stringtype see_ref = | See_url of string| See_file of string| See_doc of stringtype param = string * text type raised_exception = string * text type alert = { alert_name : string; alert_payload : string option ; } type info = { i_desc : text option i_authors : string list ; i_version : string option ; i_sees : see list i_since : string option ; i_before : (string * text ) list i_deprecated : text option i_params : param list i_raised_exceptions : raised_exception list i_return_value : text option i_custom : (string * text ) list i_alerts : alert list } type merge_option = | Merge_description | Merge_author | Merge_version | Merge_see | Merge_since | Merge_before | Merge_deprecated | Merge_param | Merge_raised_exception | Merge_return_value | Merge_custom val make_dump : 'a -> 'a dump val open_dump : 'a dump -> 'a Odoc_value (ocaml.Odoc_value) Up – ocaml » Odoc_valueTypes
Representation of a value.
type t_attribute = { att_value : t_value ; att_mutable : bool; att_virtual : bool; } Representation of a class attribute.
type t_method = { met_value : t_value ; met_private : bool; met_virtual : bool; } Representation of a class method.
Functions
val value_parameter_text_by_name : t_value -> string -> Odoc_types.text optionReturns the text associated to the given parameter name in the given value, or None.
val update_value_parameters_text : t_value -> Update the parameters text of a t_value, according to the val_info field.
Create a list of parameters with dummy names "??" from a type list. Used when we want to merge the parameters of a value, from the .ml and the .mli file. In the .mli file we don't have parameter names so there is nothing to merge. With this dummy list we can merge the parameter names from the .ml and the type from the .mli file.
Return true if the value is a function, i.e. has a functional type.
Opcodes (ocaml.Opcodes) Up – ocaml » Opcodesval opOFFSETCLOSUREM3 : intval opOFFSETCLOSURE0 : intval opOFFSETCLOSURE3 : intval opOFFSETCLOSURE : intval opPUSHOFFSETCLOSUREM3 : intval opPUSHOFFSETCLOSURE0 : intval opPUSHOFFSETCLOSURE3 : intval opPUSHOFFSETCLOSURE : intval opPUSHGETGLOBAL : intval opGETGLOBALFIELD : intval opPUSHGETGLOBALFIELD : intval opMAKEFLOATBLOCK : intval opGETFLOATFIELD : intval opSETFLOATFIELD : intval opCHECK_SIGNALS : intval opRAISE_NOTRACE : intval opGETSTRINGCHAR : intOprint (ocaml.Oprint) Up – ocaml » Oprintval parenthesized_ident : string -> boolOptcompile (ocaml.Optcompile) Up – ocaml » Optcompileval interface : source_file :string -> output_prefix :string -> *
clambda info typed applies the regular compilation pipeline to the given typechecked implementation and outputs the resulting files.
flambda info backend typed applies the Flambda compilation pipeline to the given typechecked implementation and outputs the resulting files.
Opterrors (ocaml.Opterrors) Up – ocaml » OpterrorsOptmain (ocaml.Optmain) Up – ocaml » Optmain
diff --git a/ocaml/Optmaindriver/index.html b/ocaml/Optmaindriver/index.html
new file mode 100644
index 00000000..5578b02d
--- /dev/null
+++ b/ocaml/Optmaindriver/index.html
@@ -0,0 +1,2 @@
+
+Optmaindriver (ocaml.Optmaindriver) Up – ocaml » OptmaindriverOutcometree (ocaml.Outcometree) Up – ocaml » Outcometreetype out_name = { mutable printed_name : string;} An out_name is a string representation of an identifier which can be rewritten on the fly to avoid name collisions
type out_string = | Ostr_string | Ostr_bytes type out_attribute = { oattr_name : string; } and out_constructor = { ocstr_name : string; ocstr_args : out_type list ocstr_return_type : out_type option } and out_variant = | Ovar_fields of (string * bool * out_type list list| Ovar_typ of out_type and out_class_sig_item = | Ocsg_constraint of out_type * out_type | Ocsg_method of string * bool * bool * out_type | Ocsg_value of string * bool * bool * out_type 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_val_decl = { oval_name : string; oval_type : out_type ; oval_prims : string list ; oval_attributes : out_attribute list } and out_rec_status = | Orec_not | Orec_first | Orec_next and out_ext_status = | Oext_first | Oext_next | Oext_exception List (ocaml.Parameter.List) Up – ocaml » Parameter » Listextract variables from a list of parameters, preserving the order
Map (ocaml.Parameter.Map) Up – ocaml » Parameter » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Parameter.Set) Up – ocaml » Parameter » Setinclude Identifiable.Set with module T := T include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Parameter.T) Up – ocaml » Parameter » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Parameter.Tbl) Up – ocaml » Parameter » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Parameter (ocaml.Parameter) Up – ocaml » ParameterMake a parameter from a variable with default attributes
Rename the inner variable of the parameter
include Identifiable.S with type t := t and module T := T and module Set := Set include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
module List : sig ... end _ (ocaml.Parmatch.Compat._) Up – ocaml » Parmatch » Compat » _Compat (ocaml.Parmatch.Compat) Up – ocaml » Parmatch » CompatParmatch (ocaml.Parmatch) Up – ocaml » Parmatchconst_compare c1 c2 compares the actual values represented by c1 and c2, while simply using Stdlib.compare would compare the representations.
cf. MPR#5758
le_pat p q means: forall V, V matches q implies V matches p
le_pats (p1 .. pm) (q1 .. qn) means: forall i <= m, le_pat pi qi
module Compat (_ : sig ... end ) : sig ... end Exported compatibility functor, abstracted over constructor equality
lub p q is a pattern that matches all values matched by p and q. May raise Empty, when p and q are not compatible.
lubs [p1; ...; pn] [q1; ...; qk], where n < k, is [lub p1 q1; ...; lub pk qk].
val get_mins : ('a -> 'a -> -> 'a list-> 'a 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 '_'
pats_of_type builds a list of patterns from a given expected type, for explosion of wildcard patterns in Typecore.type_pat.
There are four interesting cases:
the type is empty () no further explosion is necessary (Pat_any) a single pattern is generated, from a record or tuple type or a single-variant type (tp) a list of patterns, in the case that all branches are GADT constructors (tp1; ..; tpn). check_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.
An 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.
Parse (ocaml.Parse) Up – ocaml » ParseThe functions below can be used to parse Longident safely.
The function longident is guaranteed to parse all subclasses of Longident.t
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
This 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.tA.Path.To.(.%.%.(;..)<-)
This 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.ttrue,false,(),[],(::). Among those special constructors, only (::) can be prefixed by a module path (A.B.C.(::)).
This 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
This 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
This 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.
Incremental (ocaml.Parser.Incremental) Up – ocaml » Parser » IncrementalModule Parser.Incremental MenhirInterpreter (ocaml.Parser.MenhirInterpreter) Up – ocaml » Parser » MenhirInterpreterModule Parser.MenhirInterpreter Parser (ocaml.Parser) Up – ocaml » ParserParsetree (ocaml.Parsetree) Up – ocaml » Parsetreetype constant = | Pconst_integer of string * char option Integer 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 char| Pconst_string of string * Location.t * string option Constant 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 option Float 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.
Attributes such as [\@id ARG] and [\@\@id ARG].
Metadata containers passed around within the AST. The compiler ignores unknown attributes.
Extension points such as [%id ARG] and [%%id ARG].
Sub-language placeholder -- rejected by the typechecker.
and 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_desc = | Ptyp_any | Ptyp_var of stringA type variable such as 'a
| Ptyp_arrow of Asttypes.arg_label * core_type * core_type Ptyp_arrow(lbl, T1, T2) represents:
| 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 listAsttypes.closed_flag Ptyp_object([ l1:T1; ...; ln:Tn ], flag) represents:
< l1:T1; ...; ln:Tn > when flag is Closed< l1:T1; ...; ln:Tn; .. > when flag is Open| 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 * string| Ptyp_variant of row_field listAsttypes.closed_flag
+ * Asttypes.label listPtyp_variant([`A;`B], flag, labels) represents:
[ `A|`B ] when flag is Closedlabels is None,[> `A|`B ] when flag is Openlabels is None,[< `A|`B ] when flag is Closedlabels is Some [],[< `A|`B > `X `Y ] when flag is Closedlabels is Some ["X";"Y"].| Ptyp_poly of string Asttypes.loc listcore_type 'a1 ... 'an. T
Can only appear in the following context:
| Ptyp_package of package_type | Ptyp_extension of extension As package_type
(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 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].The 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 and pattern_desc = | Ppat_any | Ppat_var of string Asttypes.loc A variable pattern such as x
| Ppat_alias of pattern * string Asttypes.loc An alias pattern such as P as 'a
| Ppat_constant of constant Patterns such as 1, 'a', "true", 1.0, 1l, 1L, 1n
| Ppat_interval of constant * constant Patterns 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 listpattern ) 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 ) listAsttypes.closed_flag Ppat_record([(l1, P1) ; ... ; (ln, Pn)], flag) represents:
{ l1=P1; ...; ln=Pn } when flag is Closed{ l1=P1; ...; ln=Pn; _} when flag is OpenInvariant: n > 0
| Ppat_array of pattern listPattern [| P1; ...; Pn |]
| Ppat_or of pattern * pattern | Ppat_constraint of pattern * core_type | Ppat_type of Longident.t Asttypes.loc | Ppat_lazy of pattern | Ppat_unpack of string option Asttypes.loc Ppat_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 pattern | Ppat_extension of extension | Ppat_open of Longident.t Asttypes.loc pattern and expression_desc = | Pexp_ident of Longident.t Asttypes.loc Identifiers such as x and M.x
| Pexp_constant of constant Expressions constant such as 1, 'a', "true", 1.0, 1l, 1L, 1n
| Pexp_let of Asttypes.rec_flag * value_binding listexpression Pexp_let(flag, [(P1,E1) ; ... ; (Pn,En)], E) represents:
let P1 = E1 and ... and Pn = EN in E when flag is Nonrecursivelet 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 optionpattern * expression Pexp_fun(lbl, exp0, P, E1) represents:
fun P -> E1 when lbl is Nolabelexp0 is Nonefun ~l:P -> E1 when lbl is Labelled lexp0 is Nonefun ?l:P -> E1 when lbl is Optional lexp0 is Nonefun ?l:(P = E0) -> E1 when lbl is Optional lexp0 is Some E0Notes:
If E0 is provided, only Optional fun P1 P2 .. Pn -> E1 is represented as nested Pexp_funlet f P = E is represented using Pexp_fun| Pexp_apply of expression * (Asttypes.arg_label * expression ) listPexp_apply(E0, [(l1, E1) ; ... ; (ln, En)]) represents E0 ~l1:E1 ... ~ln:En
li can be NolabelLabelledOptional
Invariant: n > 0
| 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 ) listexpression 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.loc | Pexp_setfield of expression * Longident.t Asttypes.loc expression | Pexp_array of expression list| Pexp_ifthenelse of expression * expression * expression option| Pexp_sequence of expression * expression | Pexp_while of expression * expression | Pexp_for of pattern
+ * expression
+ * expression
+ * Asttypes.direction_flag
+ * expression Pexp_for(i, E1, E2, direction, E3) represents:
for i = E1 to E2 do E3 done when direction is Uptofor i = E1 downto E2 do E3 done when direction is Downto| Pexp_constraint of expression * core_type | Pexp_coerce of expression * core_type optioncore_type Pexp_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.loc | Pexp_new of Longident.t Asttypes.loc | Pexp_setinstvar of Asttypes.label Asttypes.loc expression | Pexp_override of (Asttypes.label Asttypes.loc expression ) list{< x1 = E1; ...; xn = En >}
| Pexp_letmodule of string option Asttypes.loc module_expr * expression | Pexp_letexception of extension_constructor * expression | Pexp_assert of expression assert E.
Note: assert false is treated in a special way by the type-checker.
| Pexp_lazy of expression | Pexp_poly of expression * core_type optionUsed for method bodies.
Can only be used as the expression under Cfk_concrete
| Pexp_object of class_structure | Pexp_newtype of string Asttypes.loc * expression | 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 * expression M.(E)let open M in Elet open! M in E| Pexp_letop of letop let* P = E0 in E1let* P0 = E00 and* P1 = E01 in E1| Pexp_extension of extension | Pexp_unreachable Values of type case(P -> E) or (P when E0 -> E)
Here are type declarations and their representation, for various ptype_kindptype_manifest
type t when type_kind is Ptype_abstractmanifest is None,type t = T0 when type_kind is Ptype_abstractmanifest is Some T0,type t = C of T | ... when type_kind is Ptype_variantmanifest is None,type t = T0 = C of T | ... when type_kind is Ptype_variantmanifest is Some T0,type t = {l: T; ...} when type_kind is Ptype_recordmanifest is None,type t = T0 = {l : T; ...} when type_kind is Ptype_recordmanifest is Some T0,type t = .. when type_kind is Ptype_openmanifest is None.and constructor_arguments = | Pcstr_tuple of core_type list| Pcstr_record of label_declaration listValues of type constructor_declaration
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 [...].Definition of new extensions constructors for the extensive sum type t (type t += ...).
Definition of a new exception (exception E).
Values of type class_signature represents:
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_expr_desc = | Pcl_constr of Longident.t Asttypes.loc core_type list| Pcl_structure of class_structure | Pcl_fun of Asttypes.arg_label * expression optionpattern * class_expr Pcl_fun(lbl, exp0, P, CE) represents:
fun P -> CE when lbl is Nolabelexp0 is None,fun ~l:P -> CE when lbl is Labelled lexp0 is None,fun ?l:P -> CE when lbl is Optional lexp0 is None,fun ?l:(P = E0) -> CE when lbl is Optional lexp0 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 listclass_expr Pcl_let(rec, [(P1, E1); ... ; (Pn, En)], CE) represents:
let P1 = E1 and ... and Pn = EN in CE when rec is Nonrecursivelet rec P1 = E1 and ... and Pn = EN in CE when rec is Recursive| Pcl_constraint of class_expr * class_type | Pcl_extension of extension | Pcl_open of open_description * class_expr and functor_parameter = | Unit | Named of string option Asttypes.loc module_type Named(name, MT) represents:
(X : MT) when name is Some X,(_ : MT) when name is NoneValues of type module_declaration represents S : MT
Values of type module_substitution represents S := M
Values of type module_type_declaration represents:
S = MT,S for abstract module type declaration, when pmtd_typeNone.Values of type 'a open_infos represents:
Values of type open_description represents:
Values of type open_declaration represents:
open M.Nopen M(N).Oopen struct ... endValues of type include_description represents include MT
Values of type include_declaration represents include ME
and value_constraint = | Pvc_constraint of { locally_abstract_univars : string Asttypes.loc list typ : core_type ; } | Pvc_coercion of { ground : core_type option coercion : core_type ; } Pvc_constraint { locally_abstract_univars=[]; typ} is a simple type constraint on a value binding: let x : typMore generally, in Pvc_constraint { locally_abstract_univars; typ} locally_abstract_univars is the list of locally abstract type variables in let x: type a ... . typ Pvc_coercion { ground=None; coercion } represents let x :> typPvc_coercion { ground=Some g; coercion } represents let x : g :> typlet pat : type_constraint = exp
Values of type module_binding represents module X = ME
and directive_argument_desc = | Pdir_string of string| Pdir_int of string * char option | Pdir_ident of Longident.t | Pdir_bool of boolPass_wrapper (ocaml.Pass_wrapper) Up – ocaml » Pass_wrapperval register : pass_name :string -> Map (ocaml.Path.Map) Up – ocaml » Path » MapThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Set (ocaml.Path.Set) Up – ocaml » Path » SetThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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, but returns the largest element of the given set.
val max_elt_opt : t -> elt optionSame 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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Path (ocaml.Path) Up – ocaml » Pathtype t = | Pident of Ident.t | Pdot of t * stringExamples: List.map, Float.Array
| Papply of t * t Examples: Set.Make(Int), Map.Make(Set.Make(Int))
val same : t -> t -> val compare : t -> t ->
val exists_free : Ident.t list-> t -> val flatten : t -> [ `Contains_apply | `Ok of Ident.t * string list val name : ?paren :(string -> bool) -> t -> val is_constructor_typath : t -> General (ocaml.Patterns.General) Up – ocaml » Patterns » GeneralHalf_simple (ocaml.Patterns.Half_simple) Up – ocaml » Patterns » Half_simpleModule Patterns.Half_simple Head (ocaml.Patterns.Head) Up – ocaml » Patterns » Headdeconstruct p returns the head of p and the list of sub patterns.
reconstructs a pattern, putting wildcards as sub-patterns.
Non_empty_row (ocaml.Patterns.Non_empty_row) Up – ocaml » Patterns » Non_empty_rowModule Patterns.Non_empty_row 'assert false' on empty rows
val map_first : ('a -> 'b ) -> 'a t -> 'b t Simple (ocaml.Patterns.Simple) Up – ocaml » Patterns » SimplePatterns (ocaml.Patterns) Up – ocaml » PatternsList.init (fun _ -> omega)
List.map (fun _ -> omega)
module Head : sig ... end Consistbl (ocaml.Persistent_env.Consistbl) Up – ocaml » Persistent_env » ConsistblModule Persistent_env.Consistbl
exception Inconsistency of { unit_name : Misc.Stdlib.String.t ; inconsistent_source : string; original_source : string; } Persistent_signature (ocaml.Persistent_env.Persistent_signature) Up – ocaml » Persistent_env » Persistent_signatureModule Persistent_env.Persistent_signature val load : (unit_name :string -> t option ref Function used to load a persistent signature. The default is to look for the .cmi file in the load path. This function can be overridden to load it from memory, for instance to build a self-contained toplevel.
Persistent_env (ocaml.Persistent_env) Up – ocaml » Persistent_envval clear_missing : 'a t -> val without_cmis : 'a t -> ('b -> 'c ) -> 'b -> 'c val add_delayed_check_forward : ((unit -> unit) -> ref Polling (ocaml.Polling) Up – ocaml » PollingPparse (ocaml.Pparse) Up – ocaml » PparseModule Pparse Driver for the parser and external preprocessors.
Warning: this module is unstable and part of compiler-libs .
type error = | CannotRun of string| WrongMagic of stringval preprocess : string -> stringval remove_preprocessed : string -> unitval read_ast : 'a ast_kind -> string -> 'a val write_ast : 'a ast_kind -> string -> 'a -> val apply_rewriters :
+ ?restore :bool -> tool_name :string -> 'a ast_kind -> 'a -> 'a If restore = true (the default), cookies set by external rewriters will be kept for later calls.
val call_external_preprocessor : string -> string -> stringval open_and_check_magic : string -> string -> in_channel * boolPprintast (ocaml.Pprintast) Up – ocaml » PprintastPrint a type variable name, taking care of the special treatment required for the single quote character in second position.
Predef (ocaml.Predef) Up – ocaml » Predefval path_extension_constructor : Path.t val path_match_failure : Path.t val path_assert_failure : Path.t val path_undefined_recursive_module : Path.t val builtin_values : (string * Ident.t ) listval builtin_idents : (string * Ident.t ) listval ident_division_by_zero : Ident.t All 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.
Primitive (ocaml.Primitive) Up – ocaml » Primitivetype boxed_integer = | Pnativeint | Pint32 | Pint64 type native_repr = | Same_as_ocaml_repr | Unboxed_float | Unboxed_integer of boxed_integer | Untagged_int type 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 -> description native_name_is_externa returns true iff the native_name for the given primitive identifies that the primitive is not implemented in the compiler itself.
type error = | Old_style_float_with_native_repr_attribute | Old_style_noalloc_with_noalloc_attribute | No_native_primitive_with_repr_attribute Printast (ocaml.Printast) Up – ocaml » PrintastPrintclambda (ocaml.Printclambda) Up – ocaml » PrintclambdaPrintclambda_primitives (ocaml.Printclambda_primitives) Up – ocaml » Printclambda_primitivesModule Printclambda_primitives Printcmm (ocaml.Printcmm) Up – ocaml » PrintcmmPrintinstr (ocaml.Printinstr) Up – ocaml » PrintinstrPrintlambda (ocaml.Printlambda) Up – ocaml » PrintlambdaPrintlinear (ocaml.Printlinear) Up – ocaml » PrintlinearPrintmach (ocaml.Printmach) Up – ocaml » PrintmachPrintpat (ocaml.Printpat) Up – ocaml » PrintpatConflicts (ocaml.Printtyp.Conflicts) Up – ocaml » Printtyp » Conflictsval exists : unit -> boolexists() returns true if the current naming context renamed an identifier to avoid a name collision
list_explanations() return the list of conflict explanations collected up to this point, and reset the list of collected explanations
Print all conflict explanations collected up to this point
Naming_context (ocaml.Printtyp.Naming_context) Up – ocaml » Printtyp » Naming_contextModule Printtyp.Naming_context val enable : bool -> unitWhen contextual names are enabled, the mapping between identifiers and names is ensured to be one-to-one.
Out_name (ocaml.Printtyp.Out_name) Up – ocaml » Printtyp » Out_nameSubtype (ocaml.Printtyp.Subtype) Up – ocaml » Printtyp » SubtypePrinttyp (ocaml.Printtyp) Up – ocaml » Printtypval string_of_path : Path.t -> Print a type path taking account of -short-paths. Calls should be within wrap_printing_env.
Print a list of paths, using the same naming context to avoid name collisions
val wrap_printing_env : error :bool -> Env.t -> (unit -> 'a ) -> 'a The 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
Print 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.
prepare_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.
add_type_to_preparation ty extend a previous type expression preparation to the type expression ty
The 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.
shared_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.
Print 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)
type type_or_scheme = | Type | Type_scheme printed_signature sourcefile ppf sg print the signature sg of sourcefile with potential warnings for name collisions
Printtyped (ocaml.Printtyped) Up – ocaml » PrinttypedProc (ocaml.Proc) Up – ocaml » Procval word_addressed : boolval num_register_classes : intval register_class : Reg.t -> val num_available_registers : int array val first_available_register : int array val register_name : int -> stringval phys_reg : int -> Reg.t val rotate_registers : boolval loc_exn_bucket : Reg.t val max_arguments_for_tailcalls : intval destroyed_at_raise : Reg.t arrayval destroyed_at_reloadretaddr : Reg.t arrayval dwarf_register_numbers : reg_class :int -> int array For 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).
val stack_ptr_dwarf_register_number : intThe DWARF register number corresponding to the stack pointer.
val assemble_file : string -> string -> intProfile (ocaml.Profile) Up – ocaml » Profileerase all recorded profile information
val record_call : ?accumulate :bool -> string -> (unit -> 'a ) -> 'a record_call pass f calls f and records its profile information.
val record : ?accumulate :bool -> string -> ('a -> 'b ) -> 'a -> 'b record pass f arg records the profile information of f arg
type column = [ | `Time | `Alloc | `Top_heap | `Abs_top_heap ] Prints the selected recorded profiling information to the formatter.
Command line flags
A few pass names that are needed in several places, and shared to avoid typos.
Profiling (ocaml.Profiling) Up – ocaml » Profilingval counters : (string * (string * int array ) ) listref val incr : int array -> int -> unitMap (ocaml.Projection.Map) Up – ocaml » Projection » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Projection.Set) Up – ocaml » Projection » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Projection.T) Up – ocaml » Projection » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Projection.Tbl) Up – ocaml » Projection » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Projection (ocaml.Projection) Up – ocaml » ProjectionThe 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.
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.
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.
include Identifiable.S with type t := t include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
Return which variable the given projection projects from.
Change the variable that the given projection projects from.
Rec_check (ocaml.Rec_check) Up – ocaml » Rec_checkRef_to_variables (ocaml.Ref_to_variables) Up – ocaml » Ref_to_variablesMap (ocaml.Reg.Map) Up – ocaml » Reg » MapThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Raw_name (ocaml.Reg.Raw_name) Up – ocaml » Reg » Raw_nameSet (ocaml.Reg.Set) Up – ocaml » Reg » SetThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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, but returns the largest element of the given set.
val max_elt_opt : t -> elt optionSame 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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Reg (ocaml.Reg) Up – ocaml » Regtype 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 listmutable prefer : (t * int) listmutable degree : int;mutable spill_cost : int;mutable visited : int;} and stack_location = | Local of int| Incoming of int| Outgoing of int| Domainstate of intval createv_like : t array-> t arrayval anonymous : t -> val disjoint_set_array : Set.t -> t array-> val set_of_array : t array-> Set.t val all_registers : unit -> t listval num_registers : unit -> intval reinit : unit -> unitval mark_visited : t -> val is_visited : t -> val clear_visited_marks : unit -> unitReload (ocaml.Reload) Up – ocaml » Reloadreload_generic (ocaml.Reloadgen.reload_generic) Up – ocaml » Reloadgen » reload_genericClass Reloadgen.reload_generic Reloadgen (ocaml.Reloadgen) Up – ocaml » ReloadgenRemove_free_vars_equal_to_args (ocaml.Remove_free_vars_equal_to_args) Up – ocaml » Remove_free_vars_equal_to_argsRemove_unused_arguments (ocaml.Remove_unused_arguments) Up – ocaml » Remove_unused_argumentsModule Remove_unused_arguments Introduce 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
Remove_unused_closure_vars (ocaml.Remove_unused_closure_vars) Up – ocaml » Remove_unused_closure_varsModule Remove_unused_closure_vars Eliminate variables bound by sets of closures that are not required. Also eliminate functions within sets of closures that are not required.
Remove_unused_program_constructs (ocaml.Remove_unused_program_constructs) Up – ocaml » Remove_unused_program_constructsModule Remove_unused_program_constructs Callbacks (ocaml.Runtime_events.Callbacks) Up – ocaml » Runtime_events » CallbacksModule Runtime_events.Callbacks Create a Callback that optionally subscribes to one or more runtime events. The first int supplied to callbacks is the ring buffer index. Each domain owns a single ring buffer for the duration of the domain's existence. After a domain terminates, a newly spawned domain may take ownership of the ring buffer. A runtime_begin callback is called when the runtime enters a new phase (e.g a runtime_begin with EV_MINOR is called at the start of a minor GC). A runtime_end callback is called when the runtime leaves a certain phase. The runtime_counter callback is called when a counter is emitted by the runtime. lifecycle callbacks are called when the ring undergoes a change in lifecycle and a consumer may need to respond. alloc callbacks are currently only called on the instrumented runtime. lost_events callbacks are called if the consumer code detects some unconsumed events have been overwritten.
add_user_event ty callback t extends t to additionally subscribe to user events of type ty. When such an event happens, callback is called with the corresponding event and payload.
Timestamp (ocaml.Runtime_events.Timestamp) Up – ocaml » Runtime_events » TimestampModule Runtime_events.Timestamp Type for the int64 timestamp to allow for future changes
val to_int64 : t -> Type (ocaml.Runtime_events.Type) Up – ocaml » Runtime_events » TypeModule Runtime_events.Type The type for a user event content type
An event that has no data associated with it
An event that has a beginning and an end
An event containing an integer value
val register :
+ encode :(bytes -> 'a -> -> decode :(bytes -> int -> 'a ) -> 'a t Registers a custom type by providing an encoder and a decoder. The encoder writes the value in the provided buffer and returns the number of bytes written. The decoder gets a slice of the buffer of specified length, and returns the decoded value.
The maximum value length is 1024 bytes.
User (ocaml.Runtime_events.User) Up – ocaml » Runtime_events » UserThe type for a user event tag. Tags are used to discriminate between user events of the same type
The type for a user event. User events describe their tag, carried data type and an unique string-based name
val register : string -> tag -> 'value Type.t -> 'value t register name tag ty registers a new event with an unique name, carrying a tag and values of type ty
val write : 'value t -> 'value -> write t v records a new event t with value v
name t is the uniquely identifying name of event t
tag t is the associated tag of event t, when it is known. An event can be unknown if it was not registered in the consumer program.
Runtime_events (ocaml.Runtime_events) Up – ocaml » Runtime_eventsModule Runtime_events Runtime events - ring buffer-based runtime tracing
This module enables users to enable and subscribe to tracing events from the Garbage Collector and other parts of the OCaml runtime. This can be useful for diagnostic or performance monitoring purposes. This module can be used to subscribe to events for the current process or external processes asynchronously.
When enabled (either via setting the OCAML_RUNTIME_EVENTS_START environment variable or calling Runtime_events.start) a file with the pid of the process and extension .events will be created. By default this is in the current directory but can be over-ridden by the OCAML_RUNTIME_EVENTS_DIR environment variable. Each domain maintains its own ring buffer in a section of the larger file into which it emits events.
There is additionally a set of C APIs in runtime_events.h that can enable zero-impact monitoring of the current process or bindings for other languages.
The runtime events system's behaviour can be controlled by the following environment variables:
OCAML_RUNTIME_EVENTS_START if set will cause the runtime events system to be started as part of the OCaml runtime initialization. OCAML_RUNTIME_EVENTS_DIR sets the directory where the runtime events ring buffers will be located. If not present the program's working directory will be used. OCAML_RUNTIME_EVENTS_PRESERVE if set will prevent the OCaml runtime from removing its ring buffers when it terminates. This can help if monitoring very short running programs. type runtime_counter = | EV_C_FORCE_MINOR_ALLOC_SMALL | EV_C_FORCE_MINOR_MAKE_VECT | EV_C_FORCE_MINOR_SET_MINOR_HEAP_SIZE | EV_C_FORCE_MINOR_MEMPROF | EV_C_MINOR_PROMOTED | EV_C_MINOR_ALLOCATED | EV_C_REQUEST_MAJOR_ALLOC_SHR | EV_C_REQUEST_MAJOR_ADJUST_GC_SPEED | EV_C_REQUEST_MINOR_REALLOC_REF_TABLE | EV_C_REQUEST_MINOR_REALLOC_EPHE_REF_TABLE | EV_C_REQUEST_MINOR_REALLOC_CUSTOM_TABLE | EV_C_MAJOR_HEAP_POOL_WORDS Total words in a Domain's major heap pools. This is the sum of unallocated and live words in each pool.
| EV_C_MAJOR_HEAP_POOL_LIVE_WORDS Current live words in a Domain's major heap pools.
| EV_C_MAJOR_HEAP_LARGE_WORDS Total words of a Domain's major heap large allocations. A large allocation is an allocation larger than the largest sized pool.
| EV_C_MAJOR_HEAP_POOL_FRAG_WORDS Words in a Domain's major heap pools lost to fragmentation. This is due to there not being a pool with the exact size of an allocation and a larger sized pool needing to be used.
| EV_C_MAJOR_HEAP_POOL_LIVE_BLOCKS Live blocks of a Domain's major heap pools.
| EV_C_MAJOR_HEAP_LARGE_BLOCKS Live blocks of a Domain's major heap large allocations.
The type for counter events emitted by the runtime
type runtime_phase = | EV_EXPLICIT_GC_SET | EV_EXPLICIT_GC_STAT | EV_EXPLICIT_GC_MINOR | EV_EXPLICIT_GC_MAJOR | EV_EXPLICIT_GC_FULL_MAJOR | EV_EXPLICIT_GC_COMPACT | EV_MAJOR | EV_MAJOR_SWEEP | EV_MAJOR_MARK_ROOTS | EV_MAJOR_MARK | EV_MINOR | EV_MINOR_LOCAL_ROOTS | EV_MINOR_FINALIZED | EV_EXPLICIT_GC_MAJOR_SLICE | EV_FINALISE_UPDATE_FIRST | EV_FINALISE_UPDATE_LAST | EV_INTERRUPT_REMOTE | EV_MAJOR_EPHE_MARK | EV_MAJOR_EPHE_SWEEP | EV_MAJOR_FINISH_MARKING | EV_MAJOR_GC_CYCLE_DOMAINS | EV_MAJOR_GC_PHASE_CHANGE | EV_MAJOR_GC_STW | EV_MAJOR_MARK_OPPORTUNISTIC | EV_MAJOR_SLICE | EV_MAJOR_FINISH_CYCLE | EV_MINOR_CLEAR | EV_MINOR_FINALIZERS_OLDIFY | EV_MINOR_GLOBAL_ROOTS | EV_MINOR_LEAVE_BARRIER | EV_STW_API_BARRIER | EV_STW_HANDLER | EV_STW_LEADER | EV_MAJOR_FINISH_SWEEPING | EV_MINOR_FINALIZERS_ADMIN | EV_MINOR_REMEMBERED_SET | EV_MINOR_REMEMBERED_SET_PROMOTE | EV_MINOR_LOCAL_ROOTS_PROMOTE | EV_DOMAIN_CONDITION_WAIT | EV_DOMAIN_RESIZE_HEAP_RESERVATION The type for span events emitted by the runtime
type lifecycle = | EV_RING_START | EV_RING_STOP | EV_RING_PAUSE | EV_RING_RESUME | EV_FORK_PARENT | EV_FORK_CHILD | EV_DOMAIN_SPAWN | EV_DOMAIN_TERMINATE Lifecycle events for the ring itself
Return a string representation of a given lifecycle event type
Return a string representation of a given runtime phase event type
Return a string representation of a given runtime counter type
Type of the cursor used when consuming
module Type : sig ... end module User : sig ... end User events is a way for libraries to provide runtime events that can be consumed by other tools. These events can carry known data types or custom values. The current maximum number of user events is 8192.
start () will start the collection of events in the runtime if not already started.
Events can be consumed by creating a cursor with create_cursor and providing a set of callbacks to be called for each type of event.
pause () will pause the collection of events in the runtime. Traces are collected if the program has called Runtime_events.start () or the OCAML_RUNTIME_EVENTS_START environment variable has been set.
val resume : unit -> unitresume () will resume the collection of events in the runtime. Traces are collected if the program has called Runtime_events.start () or the OCAML_RUNTIME_EVENTS_START environment variable has been set.
val create_cursor : (string * int) option-> cursor create_cursor path_pid creates a cursor to read from an runtime_events. Cursors can be created for runtime_events in and out of process. A runtime_events ring-buffer may have multiple cursors reading from it at any point in time and a program may have multiple cursors open concurrently (for example if multiple consumers want different sets of events). If path_pid is None then a cursor is created for the current process. Otherwise the pair contains a string path to the directory that contains the pid.events file and int pid for the runtime_events of an external process to monitor.
val free_cursor : cursor -> Free a previously created runtime_events cursor
read_poll cursor callbacks max_option calls the corresponding functions on callbacks for up to max_option events read off cursor's runtime_events and returns the number of events read.
Runtimedef (ocaml.Runtimedef) Up – ocaml » Runtimedefval builtin_exceptions : string array val builtin_primitives : string array scheduler_generic (ocaml.Schedgen.scheduler_generic) Up – ocaml » Schedgen » scheduler_genericClass Schedgen.scheduler_generic method reload_retaddr_issue_cycles : intmethod reload_retaddr_latency : intSchedgen (ocaml.Schedgen) Up – ocaml » Schedgentype code_dag_node = { instr : Linear.instruction ; delay : int; mutable sons : (code_dag_node * int) listmutable date : int;mutable length : int;mutable ancestors : int;mutable emitted_ancestors : int;} Scheduling (ocaml.Scheduling) Up – ocaml » SchedulingCoeffect (ocaml.Selectgen.Coeffect) Up – ocaml » Selectgen » CoeffectModule Selectgen.Coeffect type t = | None | Read_mutable | Arbitrary Effect (ocaml.Selectgen.Effect) Up – ocaml » Selectgen » Effecttype t = | None | Raise | Arbitrary Effect_and_coeffect (ocaml.Selectgen.Effect_and_coeffect) Up – ocaml » Selectgen » Effect_and_coeffectModule Selectgen.Effect_and_coeffect val join_list_map : 'a list-> ('a -> t ) -> t selector_generic (ocaml.Selectgen.selector_generic) Up – ocaml » Selectgen » selector_genericClass Selectgen.selector_generic method mark_tailcall : unitmethod mark_c_tailcall : unit
val contains_calls : bool ref Selectgen (ocaml.Selectgen) Up – ocaml » SelectgenSelection (ocaml.Selection) Up – ocaml » SelectionSemantics_of_primitives (ocaml.Semantics_of_primitives) Up – ocaml » Semantics_of_primitivesModule Semantics_of_primitives Description 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.
type effects = | No_effects | Only_generative_effects | Arbitrary_effects type coeffects = | No_coeffects | Has_coeffects Describe 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.
type return_type = | Float | Other Map (ocaml.Set_of_closures_id.Map) Up – ocaml » Set_of_closures_id » MapModule Set_of_closures_id.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Set_of_closures_id.Set) Up – ocaml » Set_of_closures_id » SetModule Set_of_closures_id.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Set_of_closures_id.T) Up – ocaml » Set_of_closures_id » TModule Set_of_closures_id.T include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Set_of_closures_id.Tbl) Up – ocaml » Set_of_closures_id » TblModule Set_of_closures_id.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Set_of_closures_id (ocaml.Set_of_closures_id) Up – ocaml » Set_of_closures_idModule Set_of_closures_id An identifier, unique across the whole program, that identifies a set of closures (viz. Set_of_closures).
include Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val name : t -> string option Map (ocaml.Set_of_closures_origin.Map) Up – ocaml » Set_of_closures_origin » MapModule Set_of_closures_origin.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Set_of_closures_origin.Set) Up – ocaml » Set_of_closures_origin » SetModule Set_of_closures_origin.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Set_of_closures_origin.T) Up – ocaml » Set_of_closures_origin » TModule Set_of_closures_origin.T include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Set_of_closures_origin.Tbl) Up – ocaml » Set_of_closures_origin » TblModule Set_of_closures_origin.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Set_of_closures_origin (ocaml.Set_of_closures_origin) Up – ocaml » Set_of_closures_originModule Set_of_closures_origin include Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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 (ocaml.Shape.Item.Map) Up – ocaml » Shape » Item » MapThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Item (ocaml.Shape.Item) Up – ocaml » Shape » Itemval extension_constructor : Ident.t -> t Context (ocaml.Shape.Make_reduce.Context) Up – ocaml » Shape » Make_reduce » ContextParameter Make_reduce.Context val read_unit_shape : unit_name :string -> t optionMake_reduce (ocaml.Shape.Make_reduce) Up – ocaml » Shape » Make_reduceMap (ocaml.Shape.Map) Up – ocaml » Shape » MapSig_component_kind (ocaml.Shape.Sig_component_kind) Up – ocaml » Shape » Sig_component_kindModule Shape.Sig_component_kind type t = | Value | Type | Module | Module_type | Extension_constructor | Class | Class_type val to_string : t -> val can_appear_in_types : t -> Whether the name of a component of that kind can appear in a type.
Map (ocaml.Shape.Uid.Map) Up – ocaml » Shape » Uid » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Shape.Uid.Set) Up – ocaml » Shape » Uid » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Shape.Uid.T) Up – ocaml » Shape » Uid » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Shape.Uid.Tbl) Up – ocaml » Shape » Uid » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Uid (ocaml.Shape.Uid) Up – ocaml » Shape » Uidtype t = private | Compilation_unit of string| Item of { comp_unit : string; id : int; } | Internal | Predef of stringval reinit : unit -> unitval mk : current_unit :string -> t val of_compilation_unit_id : Ident.t -> t val internal_not_actually_unique : t val for_actual_declaration : t -> include Identifiable.S with type t := t include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
Shape (ocaml.Shape) Up – ocaml » Shapemodule Item : sig ... end val for_unnamed_functor_param : var val fresh_var : ?name :string -> Uid.t -> var * t val decompose_abs : t -> (var * t ) optionval for_persistent_unit : string -> t val set_uid_if_none : t -> Uid.t -> t The Make_reduce functor is used to generate a reduction function for shapes.
val local_reduce : t -> t Share_constants (ocaml.Share_constants) Up – ocaml » Share_constantsSignature_group (ocaml.Signature_group) Up – ocaml » Signature_groupModule Signature_group Iterate 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.
Classes and class types generate ghosts signature items, we group them together before printing
flatten sig_item is x.src :: x.post_ghosts
A group of mutually recursive definition
rec_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.
The sequence seq signature iterates over signature rec_grouprec_groupfull_seq case is the not-yet traversed part of the signature.
Describe how to amend one element of a signature
!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_approx (ocaml.Simple_value_approx) Up – ocaml » Simple_value_approxtype value_string = { contents : string option ; size : int; } 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:
the "description" (for example, "the constant integer 42"); an optional variable; an optional symbol or symbol field. If the variable (resp. symbol) is present then that variable (resp. symbol) may be used to obtain the value 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 value_closure = { set_of_closures : t ; closure_id : Closure_id.t ; } and value_float_array_contents = | Contents of t array| Unknown_or_mutable Extraction of the description of approximation(s).
val descrs : t list-> descr listPretty-printing of approximations to a formatter.
Basic construction of approximations.
val value_char : char -> t val value_float : float -> t val value_mutable_float_array : size :int -> t val value_immutable_float_array : t array-> t val value_string : int -> string option -> t val value_block : Tag.t -> t array-> t Construct 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.
Construct 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.
Augment 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_variable, but for symbol information.
val augment_with_symbol_field : t -> Symbol.t -> int -> t Like augment_with_symbol, but for symbol field information.
val replace_description : t -> descr -> t Replace the description within an approximation.
Improve the description by taking the kind into account
Improve the kind by taking the description into account
val meet : really_import_approx :(t -> t ) -> t -> t -> t An approximation is "known" iff it is not Value_unknown.
An approximation is "useful" iff it is neither unknown nor bottom.
val all_not_useful : t list-> Whether all approximations in the given list do *not* satisfy useful.
val warn_on_mutation : t -> Whether 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_summary = | Nothing_done | Replaced_term Given 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.
As 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_var_to_var_using_env :
+ t -> is_present_in_env :(Variable.t -> -> 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.
type get_field_result = | Ok of t | Unreachable Given 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.
type checked_approx_for_block = | Wrong | Ok of Tag.t * t arrayTry to prove that a value with the given approximation may be used as a block.
Find 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.
Given 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.
Try 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.
Try 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.
As for check_approx_for_closure, but values coming from external compilation units with unresolved approximations are permitted.
val check_approx_for_float : t -> float option Returns the value if it can be proved to be a constant float
Returns the value if it can be proved to be a constant float array
val check_approx_for_string : t -> string option Returns the value if it can be proved to be a constant string
type switch_branch_selection = | Cannot_be_taken | Can_be_taken | Must_be_taken Check that the branch is compatible with the approximation
Create a set of function declarations based on another set of function declarations.
Creates a map from closure IDs to function declarations by iterating over all sets of closures in the given map.
Simplif (ocaml.Simplif) Up – ocaml » SimplifSimplify_boxed_int32 (ocaml.Simplify_boxed_integer_ops.Simplify_boxed_int32) Up – ocaml » Simplify_boxed_integer_ops » Simplify_boxed_int32Module Simplify_boxed_integer_ops.Simplify_boxed_int32 Simplify_boxed_int64 (ocaml.Simplify_boxed_integer_ops.Simplify_boxed_int64) Up – ocaml » Simplify_boxed_integer_ops » Simplify_boxed_int64Module Simplify_boxed_integer_ops.Simplify_boxed_int64 Simplify_boxed_nativeint (ocaml.Simplify_boxed_integer_ops.Simplify_boxed_nativeint) Up – ocaml » Simplify_boxed_integer_ops » Simplify_boxed_nativeintModule Simplify_boxed_integer_ops.Simplify_boxed_nativeint Simplify_boxed_integer_ops (ocaml.Simplify_boxed_integer_ops) Up – ocaml » Simplify_boxed_integer_opsModule Simplify_boxed_integer_ops Simplify_boxed_integer_ops_intf (ocaml.Simplify_boxed_integer_ops_intf) Up – ocaml » Simplify_boxed_integer_ops_intfModule Simplify_boxed_integer_ops_intf module type S = sig ... end S (ocaml.Simplify_boxed_integer_ops_intf.S) Up – ocaml » Simplify_boxed_integer_ops_intf » SModule type Simplify_boxed_integer_ops_intf.S Simplify_common (ocaml.Simplify_common) Up – ocaml » Simplify_commonModule 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.
const_boxed_int_expr takes an additional argument specifying the kind of boxed integer to which the given expression evaluates.
Functions for transposing the order of bytes within words of various sizes.
val swap32 : int32 -> int32val swap64 : int64 -> int64val swapnative : nativeint -> nativeintSimplify_primitives (ocaml.Simplify_primitives) Up – ocaml » Simplify_primitivesModule Simplify_primitives Simplifies an application of a primitive based on approximation information.
Spill (ocaml.Spill) Up – ocaml » SpillSplit (ocaml.Split) Up – ocaml » SplitMap (ocaml.Static_exception.Map) Up – ocaml » Static_exception » MapModule Static_exception.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Static_exception.Set) Up – ocaml » Static_exception » SetModule Static_exception.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Static_exception.T) Up – ocaml » Static_exception » TModule Static_exception.T include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Static_exception.Tbl) Up – ocaml » Static_exception » TblModule Static_exception.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Static_exception (ocaml.Static_exception) Up – ocaml » Static_exceptioninclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
Std_exit (ocaml.Std_exit) Up – ocaml » Std_exit
diff --git a/ocaml/Stdlib/Arg/index.html b/ocaml/Stdlib/Arg/index.html
new file mode 100644
index 00000000..fa21fedb
--- /dev/null
+++ b/ocaml/Stdlib/Arg/index.html
@@ -0,0 +1,38 @@
+
+Arg (ocaml.Stdlib.Arg) Up – ocaml » Stdlib » ArgModule Stdlib.Arg Parsing 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 ref Set the reference to true
| Clear of bool ref Set the reference to false
| String of string -> unitCall the function with a string argument
| Set_string of string ref Set the reference to the string argument
| Int of int -> unitCall the function with an int argument
| Set_int of int ref Set the reference to the int argument
| Float of float -> unitCall the function with a float argument
| Set_float of float ref Set 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 -> Stop interpreting keywords and call the function with all remaining arguments
| Expand of string -> string array If 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.
type anon_fun = string -> unit 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:
The reason for the error: unknown option, invalid or missing argument, etc. usage_msgThe list of options, each followed by the corresponding doc 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.parsespeclist 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:
command subcommand options where the list of options depends on the value of the subcommand argument. Arg.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.currentparse_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-help or --help is given, Arg.parse_argv raises Arg.Help
val parse_argv_dynamic :
+ ?current :int ref -> string array -> (key * spec * doc ) listref -> anon_fun -> string ->
+ unitval parse_and_expand_argv_dynamic :
+ int ref -> string array ref -> (key * spec * doc ) listref -> anon_fun -> string ->
+ unitSame as Arg.parseExpand arguments are allowed and the current
Raised by Arg.parse_argv when the user asks for help.
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
Arg.usage speclist usage_msg prints to standard error an error message that includes the list of valid options. This is the same message that Arg.parsespeclist and usage_msg are the same as for Arg.parse
Returns the message that would have been printed by Arg.usage
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.
Position (in Sys.argvArg.parseArg.parseArg.current
val read_arg : string -> string array Arg.read_arg file reads newline-terminated command line arguments from file file.
val read_arg0 : string -> string array Identical to Arg.read_arg
val write_arg : string -> string array -> Arg.write_arg file args writes the arguments args newline-terminated into the file file. If any of the arguments in args contains a newline, use Arg.write_arg0
val write_arg0 : string -> string array -> Identical to Arg.write_arg
Array (ocaml.Stdlib.Array) Up – ocaml » Stdlib » ArrayAn alias for the type of arrays.
val length : 'a array-> Return the length (number of elements) of the given array.
val get : 'a array-> int -> 'a 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.
val set : 'a array-> int -> 'a -> 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.
val make : int -> 'a -> 'a arraymake 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.
val create_float : int -> float array create_float n returns a fresh float array of length n, with uninitialized data.
val init : int -> (int -> 'a ) -> 'a arrayinit 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 in order to the integers 0 to n-1.
val make_matrix : int -> int -> 'a -> 'a arraymake_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).
val append : 'a array-> 'a array-> 'a arrayappend v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
val concat : 'a array-> 'a arraySame as append
val sub : 'a array-> int -> int -> 'a arraysub a pos len returns a fresh array of length len, containing the elements number pos to pos + len - 1 of array a.
val copy : 'a array-> 'a arraycopy a returns a copy of a, that is, a fresh array containing the same elements as a.
val fill : 'a array-> int -> int -> 'a -> fill a pos len x modifies the array a in place, storing x in elements number pos to pos + len - 1.
val blit : 'a array-> int -> 'a array-> int -> 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.
val to_list : 'a array-> 'a listto_list a returns the list of all the elements of a.
val of_list : 'a list-> 'a arrayof_list l returns a fresh array containing the elements of l.
val iter : ('a -> -> 'a array-> 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); ().
val iteri : (int -> 'a -> -> 'a array-> Same as iter
val map : ('a -> 'b ) -> 'a array-> 'b arraymap 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_inplace : ('a -> 'a ) -> 'a array-> map_inplace f a applies function f to all elements of a, and updates their values in place.
val mapi : (int -> 'a -> 'b ) -> 'a array-> 'b arraySame as map
val mapi_inplace : (int -> 'a -> 'a ) -> 'a array-> Same as map_inplace
val fold_left : ('acc -> 'a -> 'acc ) -> 'acc -> 'a array-> 'acc 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.
val fold_left_map :
+ ('acc -> 'a -> 'acc * 'b ) -> 'acc -> 'a array-> 'acc * 'b arrayfold_left_map is a combination of fold_leftmapf.
val fold_right : ('a -> 'acc -> 'acc ) -> 'a array-> 'acc -> 'acc 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.
val iter2 : ('a -> 'b -> -> 'a array-> 'b array-> iter2 f a b applies function f to all the elements of a and b.
val map2 : ('a -> 'b -> 'c ) -> 'a array-> 'b array-> 'c arraymap2 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)|].
val for_all : ('a -> -> 'a array-> 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).
val exists : ('a -> -> 'a array-> 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).
val for_all2 : ('a -> 'b -> -> 'a array-> 'b array-> Same as for_all
val exists2 : ('a -> 'b -> -> 'a array-> 'b array-> Same as exists
val mem : 'a -> 'a array-> 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).
val memq : 'a -> 'a array-> Same as mem
val find_opt : ('a -> -> 'a array-> 'a optionfind_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.
val find_index : ('a -> -> 'a array-> int option find_index f a returns Some i, where i is the index of the first element of the array a that satisfies f x, if there is such an element.
It returns None if there is no such element.
val find_map : ('a -> 'b option -> 'a array-> 'b optionfind_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.
val find_mapi : (int -> 'a -> 'b option -> 'a array-> 'b optionSame as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
val split : ('a * 'b ) array-> 'a array'b arraysplit [|(a1,b1); ...; (an,bn)|] is ([|a1; ...; an|], [|b1; ...; bn|]).
val combine : 'a array-> 'b array-> ('a * 'b ) arraycombine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|]. Raise Invalid_argument if the two arrays have different lengths.
val sort : ('a -> 'a -> -> 'a array-> 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.comparesort, 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 < 0if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0 When 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 : ('a -> 'a -> -> 'a array-> Same as sort
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
val fast_sort : ('a -> 'a -> -> 'a array-> val to_seq : 'a array-> 'a Seq.t Iterate 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.t Iterate 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
Care must be taken when concurrently accessing arrays from multiple domains: accessing an array will never crash a program, but unsynchronized accesses might yield surprising (non-sequentially-consistent) results.
Every array operation that accesses more than one array element is not atomic. This includes iteration, scanning, sorting, splitting and combining arrays.
For example, consider the following program:
let size = 100_000_000
+let a = Array.make size 1
+let d1 = Domain.spawn (fun () ->
+ Array.iteri (fun i x -> a.(i) <- x + 1) a
+)
+let d2 = Domain.spawn (fun () ->
+ Array.iteri (fun i x -> a.(i) <- 2 * x + 1) a
+)
+let () = Domain.join d1; Domain.join d2After executing this code, each field of the array a is either 2, 3, 4 or 5. If atomicity is required, then the user must implement their own synchronization (for example, using Mutex.t
If two domains only access disjoint parts of the array, then the observed behaviour is the equivalent to some sequential interleaving of the operations from the two domains.
A data race is said to occur when two domains access the same array element without synchronization and at least one of the accesses is a write. In the absence of data races, the observed behaviour is equivalent to some sequential interleaving of the operations from different domains.
Whenever possible, data races should be avoided by using synchronization to mediate the accesses to the array elements.
Indeed, in the presence of data races, programs will not crash but the observed behaviour may not be equivalent to any sequential interleaving of operations from different domains. Nevertheless, even in the presence of data races, a read operation will return the value of some prior write to that location (with a few exceptions for float arrays).
Float arrays have two supplementary caveats in the presence of data races.
First, the blit operation might copy an array byte-by-byte. Data races between such a blit operation and another operation might produce surprising values due to tearing: partial writes interleaved with other operations can create float values that would not exist with a sequential execution.
For instance, at the end of
let zeros = Array.make size 0.
+let max_floats = Array.make size Float.max_float
+let res = Array.copy zeros
+let d1 = Domain.spawn (fun () -> Array.blit zeros 0 res 0 size)
+let d2 = Domain.spawn (fun () -> Array.blit max_floats 0 res 0 size)
+let () = Domain.join d1; Domain.join d2the res array might contain values that are neither 0. nor max_float.
Second, on 32-bit architectures, getting or setting a field involves two separate memory accesses. In the presence of data races, the user may observe tearing on any operation.
ArrayLabels (ocaml.Stdlib.ArrayLabels) Up – ocaml » Stdlib » ArrayLabelsAn alias for the type of arrays.
val length : 'a array-> Return the length (number of elements) of the given array.
val get : 'a array-> int -> 'a 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.
val set : 'a array-> int -> 'a -> 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.
val make : int -> 'a -> 'a arraymake 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.
val create_float : int -> float array create_float n returns a fresh float array of length n, with uninitialized data.
val init : int -> f :(int -> 'a ) -> 'a arrayinit 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 in order to the integers 0 to n-1.
val make_matrix : dimx :int -> dimy :int -> 'a -> 'a arraymake_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).
val append : 'a array-> 'a array-> 'a arrayappend v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
val concat : 'a array-> 'a arraySame as append
val sub : 'a array-> pos :int -> len :int -> 'a arraysub a ~pos ~len returns a fresh array of length len, containing the elements number pos to pos + len - 1 of array a.
val copy : 'a array-> 'a arraycopy a returns a copy of a, that is, a fresh array containing the same elements as a.
val fill : 'a array-> pos :int -> len :int -> '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 -> 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.
val to_list : 'a array-> 'a listto_list a returns the list of all the elements of a.
val of_list : 'a list-> 'a arrayof_list l returns a fresh array containing the elements of l.
val iter : f :('a -> -> 'a array-> 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); ().
val iteri : f :(int -> 'a -> -> 'a array-> Same as iter
val map : f :('a -> 'b ) -> 'a array-> 'b arraymap ~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_inplace : f :('a -> 'a ) -> 'a array-> map_inplace ~f a applies function f to all elements of a, and updates their values in place.
val mapi : f :(int -> 'a -> 'b ) -> 'a array-> 'b arraySame as map
val mapi_inplace : f :(int -> 'a -> 'a ) -> 'a array-> Same as map_inplace
val fold_left : f :('acc -> 'a -> 'acc ) -> init :'acc -> 'a array-> 'acc 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.
val fold_left_map :
+ f :('acc -> 'a -> 'acc * 'b ) -> init :'acc -> 'a array-> 'acc * 'b arrayfold_left_map is a combination of fold_leftmapf.
val fold_right : f :('a -> 'acc -> 'acc ) -> 'a array-> init :'acc -> 'acc 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.
val iter2 : f :('a -> 'b -> -> 'a array-> 'b array-> iter2 ~f a b applies function f to all the elements of a and b.
val map2 : f :('a -> 'b -> 'c ) -> 'a array-> 'b array-> 'c arraymap2 ~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)|].
val for_all : f :('a -> -> 'a array-> 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).
val exists : f :('a -> -> 'a array-> 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).
val for_all2 : f :('a -> 'b -> -> 'a array-> 'b array-> Same as for_all
val exists2 : f :('a -> 'b -> -> 'a array-> 'b array-> Same as exists
val mem : 'a -> set :'a array-> 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).
val memq : 'a -> set :'a array-> Same as mem
val find_opt : f :('a -> -> 'a array-> 'a optionfind_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.
val find_index : f :('a -> -> 'a array-> int option find_index ~f a returns Some i, where i is the index of the first element of the array a that satisfies f x, if there is such an element.
It returns None if there is no such element.
val find_map : f :('a -> 'b option -> 'a array-> 'b optionfind_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.
val find_mapi : f :(int -> 'a -> 'b option -> 'a array-> 'b optionSame as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
val split : ('a * 'b ) array-> 'a array'b arraysplit [|(a1,b1); ...; (an,bn)|] is ([|a1; ...; an|], [|b1; ...; bn|]).
val combine : 'a array-> 'b array-> ('a * 'b ) arraycombine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|]. Raise Invalid_argument if the two arrays have different lengths.
val sort : cmp :('a -> 'a -> -> 'a array-> 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.comparesort, 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 < 0if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0 When 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 :('a -> 'a -> -> 'a array-> Same as sort
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
val fast_sort : cmp :('a -> 'a -> -> 'a array-> val to_seq : 'a array-> 'a Seq.t Iterate 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.t Iterate 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
Care must be taken when concurrently accessing arrays from multiple domains: accessing an array will never crash a program, but unsynchronized accesses might yield surprising (non-sequentially-consistent) results.
Every array operation that accesses more than one array element is not atomic. This includes iteration, scanning, sorting, splitting and combining arrays.
For example, consider the following program:
let size = 100_000_000
+let a = ArrayLabels.make size 1
+let d1 = Domain.spawn (fun () ->
+ ArrayLabels.iteri ~f:(fun i x -> a.(i) <- x + 1) a
+)
+let d2 = Domain.spawn (fun () ->
+ ArrayLabels.iteri ~f:(fun i x -> a.(i) <- 2 * x + 1) a
+)
+let () = Domain.join d1; Domain.join d2After executing this code, each field of the array a is either 2, 3, 4 or 5. If atomicity is required, then the user must implement their own synchronization (for example, using Mutex.t
If two domains only access disjoint parts of the array, then the observed behaviour is the equivalent to some sequential interleaving of the operations from the two domains.
A data race is said to occur when two domains access the same array element without synchronization and at least one of the accesses is a write. In the absence of data races, the observed behaviour is equivalent to some sequential interleaving of the operations from different domains.
Whenever possible, data races should be avoided by using synchronization to mediate the accesses to the array elements.
Indeed, in the presence of data races, programs will not crash but the observed behaviour may not be equivalent to any sequential interleaving of operations from different domains. Nevertheless, even in the presence of data races, a read operation will return the value of some prior write to that location (with a few exceptions for float arrays).
Float arrays have two supplementary caveats in the presence of data races.
First, the blit operation might copy an array byte-by-byte. Data races between such a blit operation and another operation might produce surprising values due to tearing: partial writes interleaved with other operations can create float values that would not exist with a sequential execution.
For instance, at the end of
let zeros = Array.make size 0.
+let max_floats = Array.make size Float.max_float
+let res = Array.copy zeros
+let d1 = Domain.spawn (fun () -> Array.blit zeros 0 res 0 size)
+let d2 = Domain.spawn (fun () -> Array.blit max_floats 0 res 0 size)
+let () = Domain.join d1; Domain.join d2the res array might contain values that are neither 0. nor max_float.
Second, on 32-bit architectures, getting or setting a field involves two separate memory accesses. In the presence of data races, the user may observe tearing on any operation.
Atomic (ocaml.Stdlib.Atomic) Up – ocaml » Stdlib » AtomicAn atomic (mutable) reference to a value of type 'a.
Create an atomic reference.
Get the current value of the atomic reference.
val set : 'a t -> 'a -> Set a new value for the atomic reference.
val exchange : 'a t -> 'a -> 'a Set a new value for the atomic reference, and return the current value.
val compare_and_set : 'a t -> 'a -> 'a -> compare_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).
incr r atomically increments the value of r by 1.
decr r atomically decrements the value of r by 1.
A basic use case is to have global counters that are updated in a thread-safe way, for example to keep some sorts of metrics over IOs performed by the program. Another basic use case is to coordinate the termination of threads in a given program, for example when one thread finds an answer, or when the program is shut down by the user.
Here, for example, we're going to try to find a number whose hash satisfies a basic property. To do that, we'll run multiple threads which will try random numbers until they find one that works.
Of course the output below is a sample run and will change every time the program is run.
(* use for termination *)
+let stop_all_threads = Atomic.make false
+
+(* total number of individual attempts to find a number *)
+let num_attempts = Atomic.make 0
+
+(* find a number that satisfies [p], by... trying random numbers
+ until one fits. *)
+let find_number_where (p:int -> bool) =
+ let rand = Random.State.make_self_init() in
+ while not (Atomic.get stop_all_threads) do
+
+ let n = Random.State.full_int rand max_int in
+ ignore (Atomic.fetch_and_add num_attempts 1 : int);
+
+ if p (Hashtbl.hash n) then (
+ Printf.printf "found %d (hash=%d)\n%!" n (Hashtbl.hash n);
+ Atomic.set stop_all_threads true; (* signal all threads to stop *)
+ )
+ done;;
+
+
+(* run multiple domains to search for a [n] where [hash n <= 100] *)
+let () =
+ let criterion n = n <= 100 in
+ let threads =
+ Array.init 8
+ (fun _ -> Domain.spawn (fun () -> find_number_where criterion))
+ in
+ Array.iter Domain.join threads;
+ Printf.printf "total number of attempts: %d\n%!"
+ (Atomic.get num_attempts) ;;
+
+- : unit = ()
+found 1651745641680046833 (hash=33)
+total number of attempts: 30230350Another example is a basic Treiber stack (a thread-safe stack) that can be safely shared between threads.
Note how both push and pop are recursive, because they attempt to swap the new stack (with one more, or one fewer, element) with the old stack. This is optimistic concurrency: each iteration of, say, push stack x gets the old stack l, and hopes that by the time it tries to replace l with x::l, nobody else has had time to modify the list. If the compare_and_set fails it means we were too optimistic, and must try again.
type 'a stack = 'a list Atomic.t
+
+let rec push (stack: _ stack) elt : unit =
+ let cur = Atomic.get stack in
+ let success = Atomic.compare_and_set stack cur (elt :: cur) in
+ if not success then
+ push stack elt
+
+let rec pop (stack: _ stack) : _ option =
+ let cur = Atomic.get stack in
+ match cur with
+ | [] -> None
+ | x :: tail ->
+ let success = Atomic.compare_and_set stack cur tail in
+ if success then Some x
+ else pop stack
+
+# let st = Atomic.make []
+# push st 1
+- : unit = ()
+# push st 2
+- : unit = ()
+# pop st
+- : int option = Some 2
+# pop st
+- : int option = Some 1
+# pop st
+- : int option = NoneArray0 (ocaml.Stdlib.Bigarray.Array0) Up – ocaml » Stdlib » Bigarray » Array0Module Bigarray.Array0 Zero-dimensional arrays. The Array0 structure provides operations similar to those of Bigarray.Genarray
The type of zero-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
val create : ('a , 'b ) kind -> 'c layout -> ('a , 'b , 'c ) t 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
val init : ('a , 'b ) kind -> 'c layout -> 'a -> ('a , 'b , 'c ) t Array0.init kind layout v behaves like Array0.create kind layout except that the element is additionally initialized to the value v.
val kind : ('a , 'b , 'c ) t -> ('a , 'b ) kind Return the kind of the given Bigarray.
val layout : ('a , 'b , 'c ) t -> 'c layout Return the layout of the given Bigarray.
val change_layout : ('a , 'b , 'c ) t -> 'd layout -> ('a , 'b , 'd ) t 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 -> val get : ('a , 'b , 'c ) t -> 'a Array0.get a returns the only element in a.
val set : ('a , 'b , 'c ) t -> 'a -> Array0.set a x v stores the value v in a.
val blit : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t -> Copy the first Bigarray to the second Bigarray. See Genarray.blit
val fill : ('a , 'b , 'c ) t -> 'a -> Fill the given Bigarray with the given value. See Genarray.fill
val of_value : ('a , 'b ) kind -> 'c layout -> 'a -> ('a , 'b , 'c ) t Build a zero-dimensional Bigarray initialized from the given value.
Array1 (ocaml.Stdlib.Bigarray.Array1) Up – ocaml » Stdlib » Bigarray » Array1Module Bigarray.Array1 One-dimensional arrays. The Array1 structure provides operations similar to those of Bigarray.GenarrayArray2Array3
The type of one-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
val create : ('a , 'b ) kind -> 'c layout -> int -> ('a , 'b , 'c ) t 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
val init : ('a , 'b ) kind -> 'c layout -> int -> (int -> 'a ) -> ('a , 'b , 'c ) t 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 -> Return the size (dimension) of the given one-dimensional Bigarray.
val kind : ('a , 'b , 'c ) t -> ('a , 'b ) kind Return the kind of the given Bigarray.
val layout : ('a , 'b , 'c ) t -> 'c layout Return the layout of the given Bigarray.
val change_layout : ('a , 'b , 'c ) t -> 'd layout -> ('a , 'b , 'd ) t 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 -> val get : ('a , 'b , 'c ) t -> int -> 'a Array1.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 -> Array1.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.getInvalid_argument is raised.
val sub : ('a , 'b , 'c ) t -> int -> int -> ('a , 'b , 'c ) t Extract a sub-array of the given one-dimensional Bigarray. See Genarray.sub_left
val slice : ('a , 'b , 'c ) t -> int -> ('a , 'b , 'c ) Array0.t val blit : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t -> Copy the first Bigarray to the second Bigarray. See Genarray.blit
val fill : ('a , 'b , 'c ) t -> 'a -> Fill the given Bigarray with the given value. See Genarray.fill
val of_array : ('a , 'b ) kind -> 'c layout -> 'a array-> ('a , 'b , 'c ) t Build a one-dimensional Bigarray initialized from the given array.
val unsafe_get : ('a , 'b , 'c ) t -> int -> 'a Like Bigarray.Array1.get
val unsafe_set : ('a , 'b , 'c ) t -> int -> 'a -> Like Bigarray.Array1.set
Array2 (ocaml.Stdlib.Bigarray.Array2) Up – ocaml » Stdlib » Bigarray » Array2The type of two-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
val create : ('a , 'b ) kind -> 'c layout -> int -> int -> ('a , 'b , 'c ) t 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 ) t Array2.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 -> Return the first dimension of the given two-dimensional Bigarray.
val dim2 : ('a , 'b , 'c ) t -> Return the second dimension of the given two-dimensional Bigarray.
val kind : ('a , 'b , 'c ) t -> ('a , 'b ) kind Return the kind of the given Bigarray.
val layout : ('a , 'b , 'c ) t -> 'c layout Return the layout of the given Bigarray.
val change_layout : ('a , 'b , 'c ) t -> 'd layout -> ('a , 'b , 'd ) t 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 -> val get : ('a , 'b , 'c ) t -> int -> int -> 'a Array2.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.getInvalid_argument is raised.
val set : ('a , 'b , 'c ) t -> int -> int -> 'a -> Array2.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.setInvalid_argument is raised.
Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the first dimension. See Bigarray.Genarray.sub_leftArray2.sub_left applies only to arrays with C layout.
Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the second dimension. See Bigarray.Genarray.sub_rightArray2.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_leftArray2.slice_left applies only to arrays with C layout.
Extract 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_rightArray2.slice_right applies only to arrays with Fortran layout.
val blit : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t -> val fill : ('a , 'b , 'c ) t -> 'a -> val of_array : ('a , 'b ) kind -> 'c layout -> 'a array-> ('a , 'b , 'c ) t Build a two-dimensional Bigarray initialized from the given array of arrays.
val unsafe_get : ('a , 'b , 'c ) t -> int -> int -> 'a val unsafe_set : ('a , 'b , 'c ) t -> int -> int -> 'a -> Array3 (ocaml.Stdlib.Bigarray.Array3) Up – ocaml » Stdlib » Bigarray » Array3The type of three-dimensional Bigarrays whose elements have OCaml type 'a, representation kind 'b, and memory layout 'c.
val create : ('a , 'b ) kind -> 'c layout -> int -> int -> int -> ('a , 'b , 'c ) t 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 ) t Array3.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 -> Return the first dimension of the given three-dimensional Bigarray.
val dim2 : ('a , 'b , 'c ) t -> Return the second dimension of the given three-dimensional Bigarray.
val dim3 : ('a , 'b , 'c ) t -> Return the third dimension of the given three-dimensional Bigarray.
val kind : ('a , 'b , 'c ) t -> ('a , 'b ) kind Return the kind of the given Bigarray.
val layout : ('a , 'b , 'c ) t -> 'c layout Return the layout of the given Bigarray.
val change_layout : ('a , 'b , 'c ) t -> 'd layout -> ('a , 'b , 'd ) t 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 -> val get : ('a , 'b , 'c ) t -> int -> int -> int -> 'a Array3.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.getInvalid_argument is raised.
val set : ('a , 'b , 'c ) t -> int -> int -> int -> 'a -> Array3.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.setInvalid_argument is raised.
Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the first dimension. See Bigarray.Genarray.sub_leftArray3.sub_left applies only to arrays with C layout.
Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the second dimension. See Bigarray.Genarray.sub_rightArray3.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_leftArray3.slice_left_1 applies only to arrays with C layout.
Extract 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_rightArray3.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_leftArray3.slice_left_2 applies only to arrays with C layout.
Extract 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_rightArray3.slice_right_2 applies only to arrays with Fortran layout.
val blit : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t -> val fill : ('a , 'b , 'c ) t -> 'a -> val of_array :
+ ('a , 'b ) kind -> 'c layout -> 'a array-> ('a , 'b , 'c ) t Build a three-dimensional Bigarray initialized from the given array of arrays of arrays.
val unsafe_get : ('a , 'b , 'c ) t -> int -> int -> int -> 'a val unsafe_set : ('a , 'b , 'c ) t -> int -> int -> int -> 'a -> Genarray (ocaml.Stdlib.Bigarray.Genarray) Up – ocaml » Stdlib » 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:
the first parameter, 'a, is the OCaml type for accessing array elements (float, int, int32, int64, nativeint); the second parameter, 'b, is the actual kind of array elements (float32_elt, float64_elt, int8_signed_elt, int8_unsigned_elt, etc); the third parameter, '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.
val create : ('a , 'b ) kind -> 'c layout -> int array -> ('a , 'b , 'c ) t 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.
val init :
+ ('a , 'b ) kind -> 'c layout -> int array -> (int array -> 'a ) -> ('a , 'b , 'c ) t 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 -> Return the number of dimensions of the given Bigarray.
val dims : ('a , 'b , 'c ) t -> int array Genarray.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.
val kind : ('a , 'b , 'c ) t -> ('a , 'b ) kind Return the kind of the given Bigarray.
val layout : ('a , 'b , 'c ) t -> 'c layout Return the layout of the given Bigarray.
val change_layout : ('a , 'b , 'c ) t -> 'd layout -> ('a , 'b , 'd ) t 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 -> val get : ('a , 'b , 'c ) t -> int array -> 'a Read 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 -> Assign 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.
Extract 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.
Extract 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.
val blit : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t -> 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 -> Set 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.
Bigarray (ocaml.Stdlib.Bigarray) Up – ocaml » Stdlib » BigarrayModule Stdlib.Bigarray Large, 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:
Bigarrays are not limited in size, unlike OCaml arrays. (Normal float arrays are limited to 2,097,151 elements on a 32-bit platform, and normal arrays of other types to 4,194,303 elements.) Bigarrays are multi-dimensional. Any number of dimensions between 0 and 16 is supported. In contrast, OCaml arrays are mono-dimensional and require encoding multi-dimensional arrays as arrays of arrays. Bigarrays can only contain integers and floating-point numbers, while OCaml arrays can contain arbitrary OCaml data types. Bigarrays provide more space-efficient storage of integer and floating-point elements than normal OCaml arrays, in particular because they support 'small' types such as single-precision floats and 8 and 16-bit integers, in addition to the standard OCaml types of double-precision floats and 32 and 64-bit integers. The memory layout of Bigarrays is entirely compatible with that of arrays in C and Fortran, allowing large arrays to be passed back and forth between OCaml code and C / Fortran code with no data copying at all. Bigarrays support interesting high-level operations that normal arrays do not provide efficiently, such as extracting sub-arrays and 'slicing' a multi-dimensional array along certain dimensions, all without any copying. 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:
Bigarrays can contain elements of the following kinds:
IEEE single precision (32 bits) floating-point numbers (Bigarray.float32_elt IEEE double precision (64 bits) floating-point numbers (Bigarray.float64_elt IEEE single precision (2 * 32 bits) floating-point complex numbers (Bigarray.complex32_elt IEEE double precision (2 * 64 bits) floating-point complex numbers (Bigarray.complex64_elt 8-bit integers (signed or unsigned) (Bigarray.int8_signed_eltBigarray.int8_unsigned_elt 16-bit integers (signed or unsigned) (Bigarray.int16_signed_eltBigarray.int16_unsigned_elt OCaml integers (signed, 31 bits on 32-bit architectures, 63 bits on 64-bit architectures) (Bigarray.int_elt 32-bit signed integers (Bigarray.int32_elt 64-bit signed integers (Bigarray.int64_elt platform-native signed integers (32 bits on 32-bit architectures, 64 bits on 64-bit architectures) (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 float32_elt = | Float32_elt type float64_elt = | Float64_elt type int8_signed_elt = | Int8_signed_elt type int8_unsigned_elt = | Int8_unsigned_elt type int16_signed_elt = | Int16_signed_elt type int16_unsigned_elt = | Int16_unsigned_elt type int32_elt = | Int32_elt type int64_elt = | Int64_elt type nativeint_elt = | Nativeint_elt type complex32_elt = | Complex32_elt type complex64_elt = | Complex64_elt 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 ) kind To 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'As 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.tint 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 -> kind_size_in_bytes k is the number of bytes used to store an element of type k.
type c_layout = | C_layout_typ type fortran_layout = | Fortran_layout_typ 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_layoutBigarray.fortran_layout
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.
Zero-dimensional arrays. The Array0 structure provides operations similar to those of Bigarray.Genarray
One-dimensional arrays. The Array1 structure provides operations similar to those of Bigarray.GenarrayArray2Array3
Two-dimensional arrays. The Array2 structure provides operations similar to those of Bigarray.Genarray
Three-dimensional arrays. The Array3 structure provides operations similar to those of Bigarray.Genarray
Return the generic Bigarray corresponding to the given zero-dimensional Bigarray.
Return the generic Bigarray corresponding to the given one-dimensional Bigarray.
Return the generic Bigarray corresponding to the given two-dimensional Bigarray.
Return the generic Bigarray corresponding to the given three-dimensional Bigarray.
Return the zero-dimensional Bigarray corresponding to the given generic Bigarray.
Return the one-dimensional Bigarray corresponding to the given generic Bigarray.
Return the two-dimensional Bigarray corresponding to the given generic Bigarray.
Return the three-dimensional Bigarray corresponding to the given generic Bigarray.
reshape 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.
Specialized version of Bigarray.reshape
Specialized version of Bigarray.reshape
Specialized version of Bigarray.reshape
val reshape_3 :
+ ('a , 'b , 'c ) Genarray.t -> int ->
+ int ->
+ int ->
+ ('a , 'b , 'c ) Array3.t Specialized version of Bigarray.reshape
Care must be taken when concurrently accessing bigarrays from multiple domains: accessing a bigarray will never crash a program, but unsynchronized accesses might yield surprising (non-sequentially-consistent) results.
Every bigarray operation that accesses more than one array element is not atomic. This includes slicing, bliting, and filling bigarrays.
For example, consider the following program:
open Bigarray
+let size = 100_000_000
+let a = Array1.init Int C_layout size (fun _ -> 1)
+let update f a () =
+ for i = 0 to size - 1 do a.{i} <- f a.{i} done
+let d1 = Domain.spawn (update (fun x -> x + 1) a)
+let d2 = Domain.spawn (update (fun x -> 2 * x + 1) a)
+let () = Domain.join d1; Domain.join d2After executing this code, each field of the bigarray a is either 2, 3, 4 or 5. If atomicity is required, then the user must implement their own synchronization (for example, using Mutex.t
If two domains only access disjoint parts of the bigarray, then the observed behaviour is the equivalent to some sequential interleaving of the operations from the two domains.
A data race is said to occur when two domains access the same bigarray element without synchronization and at least one of the accesses is a write. In the absence of data races, the observed behaviour is equivalent to some sequential interleaving of the operations from different domains.
Whenever possible, data races should be avoided by using synchronization to mediate the accesses to the bigarray elements.
Indeed, in the presence of data races, programs will not crash but the observed behaviour may not be equivalent to any sequential interleaving of operations from different domains.
Bigarrays have a distinct caveat in the presence of data races: concurrent bigarray operations might produce surprising values due to tearing. More precisely, the interleaving of partial writes and reads might create values that would not exist with a sequential execution. For instance, at the end of
let res = Array1.init Complex64 c_layout size (fun _ -> Complex.zero)
+let d1 = Domain.spawn (fun () -> Array1.fill res Complex.one)
+let d2 = Domain.spawn (fun () -> Array1.fill res Complex.i)
+let () = Domain.join d1; Domain.join d2the res bigarray might contain values that are neither Complex.i nor Complex.one (for instance 1 + i).
Bool (ocaml.Stdlib.Bool) Up – ocaml » Stdlib » BoolModule Stdlib.Bool Boolean values.
type t = bool = | false | true 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.
not b is the boolean negation of b.
val (&&) : bool -> bool -> boole0 && 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.
val (||) : bool -> bool -> boole0 || 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.
val equal : bool -> bool -> boolequal b0 b1 is true if and only if b0 and b1 are both true or both false.
val compare : bool -> bool -> intcompare b0 b1 is a total order on boolean values. false is smaller than true.
to_int b is 0 if b is false and 1 if b is true.
val to_float : bool -> floatto_float b is 0. if b is false and 1. if b is true.
val to_string : bool -> stringto_string b is "true" if b is true and "false" if b is false.
val seeded_hash : int -> bool -> intAn unseeded hash function for booleans, with the same output value as Hashtbl.hashHashtbl.Make
Buffer (ocaml.Stdlib.Buffer) Up – ocaml » Stdlib » BufferModule Stdlib.Buffer Extensible 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 bUnsynchronized accesses
Unsynchronized accesses to a buffer may lead to an invalid buffer state. Thus, concurrent accesses to a buffer must be synchronized (for instance with a Mutex.t
The abstract type of buffers.
create 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
val contents : t -> Return a copy of the current contents of the buffer. The buffer itself is unchanged.
val to_bytes : t -> Return 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.
Return the number of characters currently contained in the buffer.
Empty 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.createn. For long-lived buffers that may have grown a lot, reset allows faster reclamation of the space used by the buffer.
output_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.
val add_utf_8_uchar : t -> Uchar.t -> add_utf_8_uchar b u appends the UTF-8 encoding of u at the end of buffer b.
val add_utf_16le_uchar : t -> Uchar.t -> add_utf_16le_uchar b u appends the UTF-16LE encoding of u at the end of buffer b.
val add_utf_16be_uchar : t -> Uchar.t -> 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:
a non empty sequence of alphanumeric or _ characters, an arbitrary sequence of characters enclosed by a pair of matching parentheses or curly brackets. An escaped $ character is a $ that immediately follows a backslash character; it then stands for a plain $. val add_buffer : t -> t -> add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1. b2 is not modified.
add_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.
val to_seqi : t -> (int * char) Seq.t Iterate on the buffer, in increasing order, yielding indices along chars.
The behavior is not specified if the buffer is modified during iteration.
val add_seq : t -> char Seq.t -> Create a buffer from the generator
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.
Bytes (ocaml.Stdlib.Bytes) Up – ocaml » Stdlib » BytesModule Stdlib.Bytes Byte 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
Bytes are represented by the OCaml type char.
The labeled version of this module can be used as described in the StdLabels
val length : bytes -> intReturn the length (number of bytes) of the argument.
val get : bytes -> int -> charget s n returns the byte at index n in argument s.
val set : bytes -> int -> char -> unitset s n c modifies s in place, replacing the byte at index n with c.
val create : int -> bytescreate n returns a new byte sequence of length n. The sequence is uninitialized and contains arbitrary bytes.
val make : int -> char -> bytesmake n c returns a new byte sequence of length n, filled with the byte c.
val init : int -> (int -> char) -> 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).
A byte sequence of size 0.
val copy : bytes -> bytesReturn a new byte sequence that contains the same bytes as the argument.
val of_string : string -> bytesReturn a new byte sequence that contains the same bytes as the given string.
val to_string : bytes -> stringReturn a new string that contains the same bytes as the given byte sequence.
val sub : bytes -> int -> int -> bytessub 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.
val sub_string : bytes -> int -> int -> stringSame as sub
val extend : bytes -> int -> int -> bytesextend 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.
val fill : bytes -> int -> int -> char -> unitfill s pos len c modifies s in place, replacing len characters with c, starting at pos.
val blit : bytes -> int -> bytes -> int -> int -> unitblit src src_pos dst dst_pos len copies len bytes from byte sequence src, starting at index src_pos, to byte 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 : string -> int -> bytes -> int -> int -> unitblit_string 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.
val concat : bytes -> bytes list -> 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.
val cat : bytes -> bytes -> bytescat s1 s2 concatenates s1 and s2 and returns the result as a new byte sequence.
val iter : (char -> unit) -> bytes -> unititer 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)); ().
val iteri : (int -> char -> unit) -> bytes -> unitSame as iter
val map : (char -> char) -> bytes -> bytesmap 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.
val mapi : (int -> char -> char) -> bytes -> bytesmapi 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.
val fold_left : ('acc -> char -> 'acc ) -> 'acc -> bytes -> 'acc 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.
val fold_right : (char -> 'acc -> 'acc ) -> bytes -> 'acc -> 'acc 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.
val for_all : (char -> bool) -> bytes -> boolfor_all p s checks if all characters in s satisfy the predicate p.
val exists : (char -> bool) -> bytes -> boolexists p s checks if at least one character of s satisfies the predicate p.
val trim : bytes -> bytesReturn a copy of the argument, without leading and trailing whitespace. The bytes regarded as whitespace are the ASCII characters ' ', '\012', '\n', '\r', and '\t'.
val escaped : bytes -> bytesReturn 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.
val index : bytes -> char -> intindex s c returns the index of the first occurrence of byte c in s.
val index_opt : bytes -> char -> int option 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.
val rindex : bytes -> char -> intrindex s c returns the index of the last occurrence of byte c in s.
val rindex_opt : bytes -> char -> int option 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.
val index_from : bytes -> int -> char -> intindex_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.
val index_from_opt : bytes -> int -> char -> int option 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.
val rindex_from : bytes -> int -> char -> intrindex_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.
val rindex_from_opt : bytes -> int -> char -> int option 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.
val contains : bytes -> char -> boolcontains s c tests if byte c appears in s.
val contains_from : bytes -> int -> char -> boolcontains_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.
val rcontains_from : bytes -> int -> char -> boolrcontains_from s stop c tests if byte c appears in s before position stop+1.
val uppercase_ascii : bytes -> bytesReturn a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.
val lowercase_ascii : bytes -> bytesReturn a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.
val capitalize_ascii : bytes -> bytesReturn a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.
val uncapitalize_ascii : bytes -> bytesReturn a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.
An alias for the type of byte sequences.
val compare : t -> t -> The comparison function for byte sequences, with the same specification as Stdlib.comparet, this function compare allows the module Bytes to be passed as argument to the functors Set.MakeMap.Make
val equal : t -> t -> The equality function for byte sequences.
val starts_with : prefix :bytes -> bytes -> boolstarts_with ~prefix s is true if and only if s starts with prefix.
val ends_with : suffix :bytes -> bytes -> boolends_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_stringof_string
val unsafe_to_string : bytes -> stringUnsafely 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: the data may be accessed and mutated Shared ownership: the data has several owners, that may only access it, not mutate it. 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.initString.mapString.mapito_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.lengthstring), 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
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.lengths should not be mutated until this closure is fully applied and returns ownership.
val unsafe_of_string : string -> bytesUnsafely 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_bytesstring type for this purpose.
val split_on_char : char -> bytes -> bytes list 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:
The list is not empty. Concatenating its elements using 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). No byte sequence in the result contains the sep character. Iterate on the string, in increasing index order. Modifications of the string during iteration will be reflected in the sequence.
val to_seqi : t -> (int * char) Seq.t Iterate on the string, in increasing order, yielding indices along chars
Create a string from the generator
get_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val set_utf_8_uchar : t -> int -> Uchar.t -> 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 -> is_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
get_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val set_utf_16be_uchar : t -> int -> Uchar.t -> 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 -> is_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
get_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val set_utf_16le_uchar : t -> int -> Uchar.t -> 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 -> is_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:
Functions that decode signed (resp. unsigned) 8-bit or 16-bit integers represented by int values sign-extend (resp. zero-extend) their result. Functions that encode 8-bit or 16-bit integers represented by int values truncate their input to their least significant bytes. val get_uint8 : bytes -> int -> intget_uint8 b i is b's unsigned 8-bit integer starting at byte index i.
val get_int8 : bytes -> int -> intget_int8 b i is b's signed 8-bit integer starting at byte index i.
val get_uint16_ne : bytes -> int -> intget_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at byte index i.
val get_uint16_be : bytes -> int -> intget_uint16_be b i is b's big-endian unsigned 16-bit integer starting at byte index i.
val get_uint16_le : bytes -> int -> intget_uint16_le b i is b's little-endian unsigned 16-bit integer starting at byte index i.
val get_int16_ne : bytes -> int -> intget_int16_ne b i is b's native-endian signed 16-bit integer starting at byte index i.
val get_int16_be : bytes -> int -> intget_int16_be b i is b's big-endian signed 16-bit integer starting at byte index i.
val get_int16_le : bytes -> int -> intget_int16_le b i is b's little-endian signed 16-bit integer starting at byte index i.
val get_int32_ne : bytes -> int -> int32get_int32_ne b i is b's native-endian 32-bit integer starting at byte index i.
val get_int32_be : bytes -> int -> int32get_int32_be b i is b's big-endian 32-bit integer starting at byte index i.
val get_int32_le : bytes -> int -> int32get_int32_le b i is b's little-endian 32-bit integer starting at byte index i.
val get_int64_ne : bytes -> int -> int64get_int64_ne b i is b's native-endian 64-bit integer starting at byte index i.
val get_int64_be : bytes -> int -> int64get_int64_be b i is b's big-endian 64-bit integer starting at byte index i.
val get_int64_le : bytes -> int -> int64get_int64_le b i is b's little-endian 64-bit integer starting at byte index i.
val set_uint8 : bytes -> int -> int -> unitset_uint8 b i v sets b's unsigned 8-bit integer starting at byte index i to v.
val set_int8 : bytes -> int -> int -> unitset_int8 b i v sets b's signed 8-bit integer starting at byte index i to v.
val set_uint16_ne : bytes -> int -> int -> unitset_uint16_ne b i v sets b's native-endian unsigned 16-bit integer starting at byte index i to v.
val set_uint16_be : bytes -> int -> int -> unitset_uint16_be b i v sets b's big-endian unsigned 16-bit integer starting at byte index i to v.
val set_uint16_le : bytes -> int -> int -> unitset_uint16_le b i v sets b's little-endian unsigned 16-bit integer starting at byte index i to v.
val set_int16_ne : bytes -> int -> int -> unitset_int16_ne b i v sets b's native-endian signed 16-bit integer starting at byte index i to v.
val set_int16_be : bytes -> int -> int -> unitset_int16_be b i v sets b's big-endian signed 16-bit integer starting at byte index i to v.
val set_int16_le : bytes -> int -> int -> unitset_int16_le b i v sets b's little-endian signed 16-bit integer starting at byte index i to v.
val set_int32_ne : bytes -> int -> int32 -> unitset_int32_ne b i v sets b's native-endian 32-bit integer starting at byte index i to v.
val set_int32_be : bytes -> int -> int32 -> unitset_int32_be b i v sets b's big-endian 32-bit integer starting at byte index i to v.
val set_int32_le : bytes -> int -> int32 -> unitset_int32_le b i v sets b's little-endian 32-bit integer starting at byte index i to v.
val set_int64_ne : bytes -> int -> int64 -> unitset_int64_ne b i v sets b's native-endian 64-bit integer starting at byte index i to v.
val set_int64_be : bytes -> int -> int64 -> unitset_int64_be b i v sets b's big-endian 64-bit integer starting at byte index i to v.
val set_int64_le : bytes -> int -> int64 -> unitset_int64_le b i v sets b's little-endian 64-bit integer starting at byte index i to v.
Care must be taken when concurrently accessing byte sequences from multiple domains: accessing a byte sequence will never crash a program, but unsynchronized accesses might yield surprising (non-sequentially-consistent) results.
Every byte sequence operation that accesses more than one byte is not atomic. This includes iteration and scanning.
For example, consider the following program:
let size = 100_000_000
+let b = Bytes.make size ' '
+let update b f () =
+ Bytes.iteri (fun i x -> Bytes.set b i (Char.chr (f (Char.code x)))) b
+let d1 = Domain.spawn (update b (fun x -> x + 1))
+let d2 = Domain.spawn (update b (fun x -> 2 * x + 1))
+let () = Domain.join d1; Domain.join d2the bytes sequence b may contain a non-deterministic mixture of '!', 'A', 'B', and 'C' values.
After executing this code, each byte of the sequence b is either '!', 'A', 'B', or 'C'. If atomicity is required, then the user must implement their own synchronization (for example, using Mutex.t
If two domains only access disjoint parts of a byte sequence, then the observed behaviour is the equivalent to some sequential interleaving of the operations from the two domains.
A data race is said to occur when two domains access the same byte without synchronization and at least one of the accesses is a write. In the absence of data races, the observed behaviour is equivalent to some sequential interleaving of the operations from different domains.
Whenever possible, data races should be avoided by using synchronization to mediate the accesses to the elements of the sequence.
Indeed, in the presence of data races, programs will not crash but the observed behaviour may not be equivalent to any sequential interleaving of operations from different domains. Nevertheless, even in the presence of data races, a read operation will return the value of some prior write to that location.
Another subtle point is that if a data race involves mixed-size writes and reads to the same location, the order in which those writes and reads are observed by domains is not specified. For instance, the following code write sequentially a 32-bit integer and a char to the same index
let b = Bytes.make 10 '\000'
+let d1 = Domain.spawn (fun () -> Bytes.set_int32_ne b 0 100; b.[0] <- 'd' )In this situation, a domain that observes the write of 'd' to b.0 is not guaranteed to also observe the write to indices 1, 2, or 3.
BytesLabels (ocaml.Stdlib.BytesLabels) Up – ocaml » Stdlib » BytesLabelsModule Stdlib.BytesLabels Byte 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
Bytes are represented by the OCaml type char.
The labeled version of this module can be used as described in the StdLabels
val length : bytes -> intReturn the length (number of bytes) of the argument.
val get : bytes -> int -> charget s n returns the byte at index n in argument s.
val set : bytes -> int -> char -> unitset s n c modifies s in place, replacing the byte at index n with c.
val create : int -> bytescreate n returns a new byte sequence of length n. The sequence is uninitialized and contains arbitrary bytes.
val make : int -> char -> bytesmake n c returns a new byte sequence of length n, filled with the byte c.
val init : int -> f :(int -> char) -> 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).
A byte sequence of size 0.
val copy : bytes -> bytesReturn a new byte sequence that contains the same bytes as the argument.
val of_string : string -> bytesReturn a new byte sequence that contains the same bytes as the given string.
val to_string : bytes -> stringReturn a new string that contains the same bytes as the given byte sequence.
val sub : bytes -> pos :int -> len :int -> 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.
val sub_string : bytes -> pos :int -> len :int -> Same as sub
val extend : bytes -> left :int -> right :int -> 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.
val fill : bytes -> pos :int -> len :int -> char -> unitfill s ~pos ~len c modifies s in place, replacing len characters with c, starting at pos.
val blit :
+ src :bytes -> src_pos :int -> dst :bytes -> dst_pos :int -> len :int -> blit ~src ~src_pos ~dst ~dst_pos ~len copies len bytes from byte sequence src, starting at index src_pos, to byte 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 -> blit_string ~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.
val concat : sep :bytes -> bytes list -> 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.
val cat : bytes -> bytes -> bytescat s1 s2 concatenates s1 and s2 and returns the result as a new byte sequence.
val iter : f :(char -> unit) -> bytes -> unititer ~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)); ().
val iteri : f :(int -> char -> unit) -> bytes -> unitSame as iter
val map : f :(char -> char) -> bytes -> bytesmap ~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.
val mapi : f :(int -> char -> char) -> bytes -> bytesmapi ~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.
val fold_left : f :('acc -> char -> 'acc ) -> init :'acc -> bytes -> 'acc 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.
val fold_right : f :(char -> 'acc -> 'acc ) -> bytes -> init :'acc -> 'acc 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.
val for_all : f :(char -> bool) -> bytes -> boolfor_all p s checks if all characters in s satisfy the predicate p.
val exists : f :(char -> bool) -> bytes -> boolexists p s checks if at least one character of s satisfies the predicate p.
val trim : bytes -> bytesReturn a copy of the argument, without leading and trailing whitespace. The bytes regarded as whitespace are the ASCII characters ' ', '\012', '\n', '\r', and '\t'.
val escaped : bytes -> bytesReturn 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.
val index : bytes -> char -> intindex s c returns the index of the first occurrence of byte c in s.
val index_opt : bytes -> char -> int option 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.
val rindex : bytes -> char -> intrindex s c returns the index of the last occurrence of byte c in s.
val rindex_opt : bytes -> char -> int option 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.
val index_from : bytes -> int -> char -> intindex_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.
val index_from_opt : bytes -> int -> char -> int option 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.
val rindex_from : bytes -> int -> char -> intrindex_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.
val rindex_from_opt : bytes -> int -> char -> int option 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.
val contains : bytes -> char -> boolcontains s c tests if byte c appears in s.
val contains_from : bytes -> int -> char -> boolcontains_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.
val rcontains_from : bytes -> int -> char -> boolrcontains_from s stop c tests if byte c appears in s before position stop+1.
val uppercase_ascii : bytes -> bytesReturn a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.
val lowercase_ascii : bytes -> bytesReturn a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.
val capitalize_ascii : bytes -> bytesReturn a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.
val uncapitalize_ascii : bytes -> bytesReturn a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.
An alias for the type of byte sequences.
val compare : t -> t -> The comparison function for byte sequences, with the same specification as Stdlib.comparet, this function compare allows the module Bytes to be passed as argument to the functors Set.MakeMap.Make
val equal : t -> t -> The equality function for byte sequences.
val starts_with : prefix :bytes -> bytes -> boolstarts_with ~prefix s is true if and only if s starts with prefix.
val ends_with : suffix :bytes -> bytes -> boolends_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_stringof_string
val unsafe_to_string : bytes -> stringUnsafely 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: the data may be accessed and mutated Shared ownership: the data has several owners, that may only access it, not mutate it. 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.initString.mapString.mapito_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.lengthstring), 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
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.lengths should not be mutated until this closure is fully applied and returns ownership.
val unsafe_of_string : string -> bytesUnsafely 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_bytesstring type for this purpose.
val split_on_char : sep :char -> bytes -> bytes list 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:
The list is not empty. Concatenating its elements using 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). No byte sequence in the result contains the sep character. Iterate on the string, in increasing index order. Modifications of the string during iteration will be reflected in the sequence.
val to_seqi : t -> (int * char) Seq.t Iterate on the string, in increasing order, yielding indices along chars
Create a string from the generator
get_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val set_utf_8_uchar : t -> int -> Uchar.t -> 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 -> is_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
get_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val set_utf_16be_uchar : t -> int -> Uchar.t -> 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 -> is_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
get_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val set_utf_16le_uchar : t -> int -> Uchar.t -> 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 -> is_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:
Functions that decode signed (resp. unsigned) 8-bit or 16-bit integers represented by int values sign-extend (resp. zero-extend) their result. Functions that encode 8-bit or 16-bit integers represented by int values truncate their input to their least significant bytes. val get_uint8 : bytes -> int -> intget_uint8 b i is b's unsigned 8-bit integer starting at byte index i.
val get_int8 : bytes -> int -> intget_int8 b i is b's signed 8-bit integer starting at byte index i.
val get_uint16_ne : bytes -> int -> intget_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at byte index i.
val get_uint16_be : bytes -> int -> intget_uint16_be b i is b's big-endian unsigned 16-bit integer starting at byte index i.
val get_uint16_le : bytes -> int -> intget_uint16_le b i is b's little-endian unsigned 16-bit integer starting at byte index i.
val get_int16_ne : bytes -> int -> intget_int16_ne b i is b's native-endian signed 16-bit integer starting at byte index i.
val get_int16_be : bytes -> int -> intget_int16_be b i is b's big-endian signed 16-bit integer starting at byte index i.
val get_int16_le : bytes -> int -> intget_int16_le b i is b's little-endian signed 16-bit integer starting at byte index i.
val get_int32_ne : bytes -> int -> int32get_int32_ne b i is b's native-endian 32-bit integer starting at byte index i.
val get_int32_be : bytes -> int -> int32get_int32_be b i is b's big-endian 32-bit integer starting at byte index i.
val get_int32_le : bytes -> int -> int32get_int32_le b i is b's little-endian 32-bit integer starting at byte index i.
val get_int64_ne : bytes -> int -> int64get_int64_ne b i is b's native-endian 64-bit integer starting at byte index i.
val get_int64_be : bytes -> int -> int64get_int64_be b i is b's big-endian 64-bit integer starting at byte index i.
val get_int64_le : bytes -> int -> int64get_int64_le b i is b's little-endian 64-bit integer starting at byte index i.
val set_uint8 : bytes -> int -> int -> unitset_uint8 b i v sets b's unsigned 8-bit integer starting at byte index i to v.
val set_int8 : bytes -> int -> int -> unitset_int8 b i v sets b's signed 8-bit integer starting at byte index i to v.
val set_uint16_ne : bytes -> int -> int -> unitset_uint16_ne b i v sets b's native-endian unsigned 16-bit integer starting at byte index i to v.
val set_uint16_be : bytes -> int -> int -> unitset_uint16_be b i v sets b's big-endian unsigned 16-bit integer starting at byte index i to v.
val set_uint16_le : bytes -> int -> int -> unitset_uint16_le b i v sets b's little-endian unsigned 16-bit integer starting at byte index i to v.
val set_int16_ne : bytes -> int -> int -> unitset_int16_ne b i v sets b's native-endian signed 16-bit integer starting at byte index i to v.
val set_int16_be : bytes -> int -> int -> unitset_int16_be b i v sets b's big-endian signed 16-bit integer starting at byte index i to v.
val set_int16_le : bytes -> int -> int -> unitset_int16_le b i v sets b's little-endian signed 16-bit integer starting at byte index i to v.
val set_int32_ne : bytes -> int -> int32 -> unitset_int32_ne b i v sets b's native-endian 32-bit integer starting at byte index i to v.
val set_int32_be : bytes -> int -> int32 -> unitset_int32_be b i v sets b's big-endian 32-bit integer starting at byte index i to v.
val set_int32_le : bytes -> int -> int32 -> unitset_int32_le b i v sets b's little-endian 32-bit integer starting at byte index i to v.
val set_int64_ne : bytes -> int -> int64 -> unitset_int64_ne b i v sets b's native-endian 64-bit integer starting at byte index i to v.
val set_int64_be : bytes -> int -> int64 -> unitset_int64_be b i v sets b's big-endian 64-bit integer starting at byte index i to v.
val set_int64_le : bytes -> int -> int64 -> unitset_int64_le b i v sets b's little-endian 64-bit integer starting at byte index i to v.
Care must be taken when concurrently accessing byte sequences from multiple domains: accessing a byte sequence will never crash a program, but unsynchronized accesses might yield surprising (non-sequentially-consistent) results.
Every byte sequence operation that accesses more than one byte is not atomic. This includes iteration and scanning.
For example, consider the following program:
let size = 100_000_000
+let b = Bytes.make size ' '
+let update b f () =
+ Bytes.iteri (fun i x -> Bytes.set b i (Char.chr (f (Char.code x)))) b
+let d1 = Domain.spawn (update b (fun x -> x + 1))
+let d2 = Domain.spawn (update b (fun x -> 2 * x + 1))
+let () = Domain.join d1; Domain.join d2the bytes sequence b may contain a non-deterministic mixture of '!', 'A', 'B', and 'C' values.
After executing this code, each byte of the sequence b is either '!', 'A', 'B', or 'C'. If atomicity is required, then the user must implement their own synchronization (for example, using Mutex.t
If two domains only access disjoint parts of a byte sequence, then the observed behaviour is the equivalent to some sequential interleaving of the operations from the two domains.
A data race is said to occur when two domains access the same byte without synchronization and at least one of the accesses is a write. In the absence of data races, the observed behaviour is equivalent to some sequential interleaving of the operations from different domains.
Whenever possible, data races should be avoided by using synchronization to mediate the accesses to the elements of the sequence.
Indeed, in the presence of data races, programs will not crash but the observed behaviour may not be equivalent to any sequential interleaving of operations from different domains. Nevertheless, even in the presence of data races, a read operation will return the value of some prior write to that location.
Another subtle point is that if a data race involves mixed-size writes and reads to the same location, the order in which those writes and reads are observed by domains is not specified. For instance, the following code write sequentially a 32-bit integer and a char to the same index
let b = Bytes.make 10 '\000'
+let d1 = Domain.spawn (fun () -> Bytes.set_int32_ne b 0 100; b.[0] <- 'd' )In this situation, a domain that observes the write of 'd' to b.0 is not guaranteed to also observe the write to indices 1, 2, or 3.
Callback (ocaml.Stdlib.Callback) Up – ocaml » Stdlib » CallbackModule Stdlib.Callback Registering 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.
val register : string -> 'a -> 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).
val register_exception : string -> exn -> unitCallback.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.
Char (ocaml.Stdlib.Char) Up – ocaml » Stdlib » CharModule Stdlib.Char Character operations.
Return the ASCII code of the argument.
Return the character with the given ASCII code.
val escaped : char -> stringReturn 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.
val lowercase_ascii : char -> charConvert the given character to its equivalent lowercase character, using the US-ASCII character set.
val uppercase_ascii : char -> charConvert the given character to its equivalent uppercase character, using the US-ASCII character set.
An alias for the type of characters.
val compare : t -> t -> The comparison function for characters, with the same specification as Stdlib.comparet, this function compare allows the module Char to be passed as argument to the functors Set.MakeMap.Make
val equal : t -> t -> The equal function for chars.
val seeded_hash : int -> t -> An unseeded hash function for characters, with the same output value as Hashtbl.hashHashtbl.Make
Complex (ocaml.Stdlib.Complex) Up – ocaml » Stdlib » Complextype t = { re : float; im : float; } The type of complex numbers. re is the real part and im the imaginary part.
Conjugate: given the complex x + i.y, returns x - i.y.
Multiplicative inverse (1/z).
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.
Norm squared: given x + i.y, returns x^2 + y^2.
Norm: given x + i.y, returns sqrt(x^2 + y^2).
Argument. 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 -> t polar norm arg returns the complex having norm norm and argument arg.
Exponentiation. exp z returns e to the z power.
Natural logarithm (in base e).
Power function. pow z1 z2 returns z1 to the z2 power.
Condition (ocaml.Stdlib.Condition) Up – ocaml » Stdlib » ConditionModule Stdlib.Condition Condition variables.
Condition variables are useful when several threads wish to access a shared data structure that is protected by a mutex (a mutual exclusion lock).
A condition variable is a communication channel . On the receiver side, one or more threads can indicate that they wish to wait for a certain property to become true. On the sender side, a thread can signal that this property has become true, causing one (or more) waiting threads to be woken up.
For instance, in the implementation of a queue data structure, if a thread that wishes to extract an element finds that the queue is currently empty, then this thread waits for the queue to become nonempty. A thread that inserts an element into the queue signals that the queue has become nonempty. A condition variable is used for this purpose. This communication channel conveys the information that the property "the queue is nonempty" is true, or more accurately, may be true. (We explain below why the receiver of a signal cannot be certain that the property holds.)
To continue the example of the queue, assuming that the queue has a fixed maximum capacity, then a thread that wishes to insert an element may find that the queue is full. Then, this thread must wait for the queue to become not full, and a thread that extracts an element of the queue signals that the queue has become not full. Another condition variable is used for this purpose.
In short, a condition variable c is used to convey the information that a certain property P about a shared data structure D , protected by a mutex m, may be true.
Condition variables provide an efficient alternative to busy-waiting. When one wishes to wait for the property P to be true, instead of writing a busy-waiting loop:
Mutex.lock m;
+while not P do
+ Mutex.unlock m; Mutex.lock m
+done;
+<update the data structure>;
+Mutex.unlock mone uses wait
Mutex.lock m;
+while not P do
+ Condition.wait c m
+done;
+<update the data structure>;
+Mutex.unlock mThe busy-waiting loop is inefficient because the waiting thread consumes processing time and creates contention of the mutex m. Calling wait
With a condition variable c, exactly one mutex m is associated. This association is implicit: the mutex m is not explicitly passed as an argument to createc, which is the associated mutex m.
With a mutex m, several condition variables can be associated. In the example of the bounded queue, one condition variable is used to indicate that the queue is nonempty, and another condition variable is used to indicate that the queue is not full.
With a condition variable c, exactly one logical property P should be associated. Examples of such properties include "the queue is nonempty" and "the queue is not full". It is up to the programmer to keep track, for each condition variable, of the corresponding property P . A signal is sent on the condition variable c as an indication that the property P is true, or may be true. On the receiving end, however, a thread that is woken up cannot assume that P is true; after a call to waitP is true. There are several reasons why this is so. One reason is that, between the moment when the signal is sent and the moment when a waiting thread receives the signal and is scheduled, the property P may be falsified by some other thread that is able to acquire the mutex m and alter the data structure D . Another reason is that spurious wakeups may occur: a waiting thread can be woken up even if no signal was sent.
Here is a complete example, where a mutex protects a sequential unbounded queue, and where a condition variable is used to signal that the queue is nonempty.
type 'a safe_queue =
+ { queue : 'a Queue.t; mutex : Mutex.t; nonempty : Condition.t }
+
+let create () =
+ { queue = Queue.create(); mutex = Mutex.create();
+ nonempty = Condition.create() }
+
+let add v q =
+ Mutex.lock q.mutex;
+ let was_empty = Queue.is_empty q.queue in
+ Queue.add v q.queue;
+ if was_empty then Condition.broadcast q.nonempty;
+ Mutex.unlock q.mutex
+
+let take q =
+ Mutex.lock q.mutex;
+ while Queue.is_empty q.queue do Condition.wait q.nonempty q.mutex done;
+ let v = Queue.take q.queue in (* cannot fail since queue is nonempty *)
+ Mutex.unlock q.mutex;
+ vBecause the call to broadcastif the queue is nonempty, then no thread is waiting , or, in other words, if some thread is waiting, then the queue must be empty . This is a desirable property: if a thread that attempts to execute a take operation could remain suspended even though the queue is nonempty, that would be a problematic situation, known as a deadlock .
The type of condition variables.
create() creates and returns a new condition variable. This condition variable should be associated (in the programmer's mind) with a certain mutex m and with a certain property P of the data structure that is protected by the mutex m.
The call wait c m is permitted only if m is the mutex associated with the condition variable c, and only if m is currently locked. This call atomically unlocks the mutex m and suspends the current thread on the condition variable c. This thread can later be woken up after the condition variable c has been signaled via signalbroadcastm is locked again before wait returns. One cannot assume that the property P associated with the condition variable c holds when wait returns; one must explicitly test whether P holds after calling wait.
signal c wakes up one of the threads waiting on the condition variable c, if there is one. If there is none, this call has no effect.
It is recommended to call signal c inside a critical section, that is, while the mutex m associated with c is locked.
val broadcast : t -> broadcast c wakes up all threads waiting on the condition variable c. If there are none, this call has no effect.
It is recommended to call broadcast c inside a critical section, that is, while the mutex m associated with c is locked.
Digest (ocaml.Stdlib.Digest) Up – ocaml » Stdlib » DigestModule Stdlib.Digest MD5 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 type of digests: 16-character strings.
val compare : t -> t -> The comparison function for 16-character digest, with the same specification as Stdlib.compareString.comparet, this function compare allows the module Digest to be passed as argument to the functors Set.MakeMap.Make
val equal : t -> t -> The equal function for 16-character digest.
Return the digest of the given string.
Return the digest of the given byte sequence.
val substring : string -> int -> int -> t Digest.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 -> t Digest.subbytes s ofs len returns the digest of the subsequence of s starting at index ofs and containing len bytes.
If 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.
Return the digest of the file whose name is given.
Write a digest on the given output channel.
Read a digest from the given input channel.
Return the printable hexadecimal representation of the given digest.
val from_hex : string -> t Convert a hexadecimal representation back into the corresponding digest.
DLS (ocaml.Stdlib.Domain.DLS) Up – ocaml » Stdlib » Domain » DLSModule Domain.DLS Domain-local Storage
val new_key : ?split_from_parent :('a -> 'a ) -> (unit -> 'a ) -> 'a key new_key f returns a new key bound to initialiser f for accessing , domain-local variables.
If split_from_parent is not provided, the value for a new domain will be computed on-demand by the new domain: the first get call will call the initializer f and store that value.
If split_from_parent is provided, spawning a domain will derive the child value (for this key) from the parent value. This computation happens in the parent domain and it always happens, regardless of whether the child domain will use it. If the splitting function is expensive or requires child-side computation, consider using 'a Lazy.t key:
let init () = ...
+
+let split_from_parent parent_value =
+ ... parent-side computation ...;
+ lazy (
+ ... child-side computation ...
+ )
+
+let key = Domain.DLS.new_key ~split_from_parent init
+
+let get () = Lazy.force (Domain.DLS.get key)In this case a part of the computation happens on the child domain; in particular, it can access parent_value concurrently with the parent domain, which may require explicit synchronization to avoid data races.
get k returns v if a value v is associated to the key k on the calling domain's domain-local state. Sets k's value with its initialiser and returns it otherwise.
val set : 'a key -> 'a -> set k v updates the calling domain's domain-local state to associate the key k with value v. It overwrites any previous values associated to k, which cannot be restored later.
Domain (ocaml.Stdlib.Domain) Up – ocaml » Stdlib » DomainA domain of type 'a t runs independently, eventually producing a result of type 'a, or an exception
val spawn : (unit -> 'a ) -> 'a t spawn f creates a new domain that runs in parallel with the current domain.
join d blocks until domain d runs to completion. If d results in a value, then that is returned by join d. If d raises an uncaught exception, then that is re-raised by join d.
Domains have unique integer identifiers
get_id d returns the identifier of the domain d
self () is the identifier of the currently running domain
val before_first_spawn : (unit -> unit) -> before_first_spawn f registers f to be called before the first domain is spawned by the program. The functions registered with before_first_spawn are called on the main (initial) domain. The functions registered with before_first_spawn are called in 'first in, first out' order: the oldest function added with before_first_spawn is called first.
val at_exit : (unit -> unit) -> at_exit f registers f to be called when the current domain exits. Note that at_exit callbacks are domain-local and only apply to the calling domain. The registered functions are called in 'last in, first out' order: the function most recently added with at_exit is called first. An example:
let temp_file_key = Domain.DLS.new_key (fun _ ->
+ let tmp = snd (Filename.open_temp_file "" "") in
+ Domain.at_exit (fun () -> close_out_noerr tmp);
+ tmp)The snippet above creates a key that when retrieved for the first time will open a temporary file and register an at_exit callback to close it, thus guaranteeing the descriptor is not leaked in case the current domain exits.
val cpu_relax : unit -> unitIf busy-waiting, calling cpu_relax () between iterations will improve performance on some CPU architectures
val is_main_domain : unit -> boolis_main_domain () returns true if called from the initial domain.
val recommended_domain_count : unit -> intThe recommended maximum number of domains which should be running simultaneously (including domains already running).
The value returned is at least 1.
Deep (ocaml.Stdlib.Effect.Deep) Up – ocaml » Stdlib » Effect » DeepModule Effect.Deep Deep handlers
type ('a, 'b) continuation ('a,'b) continuation is a delimited continuation that expects a 'a value and returns a 'b value.
continue k x resumes the continuation k by passing x to k.
discontinue k e resumes the continuation k by raising the exception e in k.
discontinue_with_backtrace k e bt resumes the continuation k by raising the exception e in k using bt as the origin for the exception.
type ('a, 'b) handler = { retc : 'a -> 'b ; exnc : exn -> 'b ; effc : 'c. 'c t -> (('c , 'b ) continuation -> 'b ) option } ('a,'b) handler is a handler record with three fields -- retc is the value handler, exnc handles exceptions, and effc handles the effects performed by the computation enclosed by the handler.
val match_with : ('c -> 'a ) -> 'c -> ('a , 'b ) handler -> 'b match_with f v h runs the computation f v in the handler h.
type 'a effect_handler = { effc : 'b. 'b t -> (('b , 'a ) continuation -> 'a ) option } 'a effect_handler is a deep handler with an identity value handler fun x -> x and an exception handler that raises any exception fun e -> raise e.
try_with f v h runs the computation f v under the handler h.
get_callstack c n returns a description of the top of the call stack on the continuation c, with at most n entries.
Shallow (ocaml.Stdlib.Effect.Shallow) Up – ocaml » Stdlib » Effect » Shallowtype ('a, 'b) continuation ('a,'b) continuation is a delimited continuation that expects a 'a value and returns a 'b value.
fiber f constructs a continuation that runs the computation f.
type ('a, 'b) handler = { retc : 'a -> 'b ; exnc : exn -> 'b ; effc : 'c. 'c t -> (('c , 'a ) continuation -> 'b ) option } ('a,'b) handler is a handler record with three fields -- retc is the value handler, exnc handles exceptions, and effc handles the effects performed by the computation enclosed by the handler.
continue_with k v h resumes the continuation k with value v with the handler h.
discontinue_with k e h resumes the continuation k by raising the exception e with the handler h.
discontinue_with k e bt h resumes the continuation k by raising the exception e with the handler h using the raw backtrace bt as the origin of the exception.
get_callstack c n returns a description of the top of the call stack on the continuation c, with at most n entries.
Effect (ocaml.Stdlib.Effect) Up – ocaml » Stdlib » Effectexception Unhandled : 'a t -> exnUnhandled e is raised when effect e is performed and there is no handler for it.
exception Continuation_already_resumed Exception raised when a continuation is continued or discontinued more than once.
perform e performs an effect e.
module Deep : sig ... end Either (ocaml.Stdlib.Either) Up – ocaml » Stdlib » EitherModule Stdlib.Either Either 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
type ('a, 'b) t = | Left of 'a | Right of 'b A value of ('a, 'b) Either.t contains either a value of 'a or a value of 'b
val left : 'a -> ('a , 'b ) t val right : 'b -> ('a , 'b ) t val is_left : ('a , 'b ) t -> is_left (Left v) is true, is_left (Right v) is false.
val is_right : ('a , 'b ) t -> is_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
val map_left : ('a1 -> 'a2 ) -> ('a1 , 'b ) t -> ('a2 , 'b ) t map_left f e is Left (f v) if e is Left v and e if e is Right _.
val map_right : ('b1 -> 'b2 ) -> ('a , 'b1 ) t -> ('a , 'b2 ) t map_right f e is Right (f v) if e is Right v and e if e is Left _.
val map :
+ left :('a1 -> 'a2 ) -> right :('b1 -> 'b2 ) -> ('a1 , 'b1 ) t -> ('a2 , 'b2 ) t 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 -> 'c fold ~left ~right (Left v) is left v, and fold ~left ~right (Right v) is right v.
val iter : left :('a -> -> right :('b -> -> ('a , 'b ) t -> iter ~left ~right (Left v) is left v, and iter ~left ~right (Right v) is right v.
val for_all : left :('a -> -> right :('b -> -> ('a , 'b ) t -> for_all ~left ~right (Left v) is left v, and for_all ~left ~right (Right v) is right v.
val equal :
+ left :('a -> 'a -> -> right :('b -> 'b -> -> ('a , 'b ) t -> ('a , 'b ) t -> equal ~left ~right e0 e1 tests equality of e0 and e1 using left and right to respectively compare values wrapped by Left _ and Right _.
val compare :
+ left :('a -> 'a -> -> right :('b -> 'b -> -> ('a , 'b ) t -> ('a , 'b ) t -> compare ~left ~right e0 e1 totally orders e0 and e1 using left and right to respectively compare values wrapped by Left _ and Right _. Left _ values are smaller than Right _ values.
Bucket (ocaml.Stdlib.Ephemeron.K1.Bucket) Up – ocaml » Stdlib » Ephemeron » K1 » BucketA bucket is a mutable "list" of ephemerons.
val make : unit -> ('k , 'd ) t val add : ('k , 'd ) t -> 'k -> 'd -> Add an ephemeron to the bucket.
val remove : ('k , 'd ) t -> 'k -> remove 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 -> Returns an upper bound on the length of the bucket.
val clear : ('k , 'd ) t -> Remove all ephemerons from the bucket.
H (ocaml.Stdlib.Ephemeron.K1.Make.H) Up – ocaml » Stdlib » Ephemeron » K1 » Make » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Make (ocaml.Stdlib.Ephemeron.K1.Make) Up – ocaml » Stdlib » Ephemeron » K1 » MakeModule K1.Make Functor 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.
val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
H (ocaml.Stdlib.Ephemeron.K1.MakeSeeded.H) Up – ocaml » Stdlib » Ephemeron » K1 » MakeSeeded » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
MakeSeeded (ocaml.Stdlib.Ephemeron.K1.MakeSeeded) Up – ocaml » Stdlib » Ephemeron » K1 » MakeSeededval create : ?random :bool -> int -> 'a t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
K1 (ocaml.Stdlib.Ephemeron.K1) Up – ocaml » Stdlib » Ephemeron » K1Module Ephemeron.K1 Ephemerons with one key.
an ephemeron with one key
val make : 'k -> 'd -> ('k , 'd ) t Ephemeron.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
Functor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded
Bucket (ocaml.Stdlib.Ephemeron.K2.Bucket) Up – ocaml » Stdlib » Ephemeron » K2 » BucketA bucket is a mutable "list" of ephemerons.
val make : unit -> ('k1 , 'k2 , 'd ) t val add : ('k1 , 'k2 , 'd ) t -> 'k1 -> 'k2 -> 'd -> Add an ephemeron to the bucket.
val remove : ('k1 , 'k2 , 'd ) t -> 'k1 -> 'k2 -> remove 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 -> Returns an upper bound on the length of the bucket.
val clear : ('k1 , 'k2 , 'd ) t -> Remove all ephemerons from the bucket.
H1 (ocaml.Stdlib.Ephemeron.K2.Make.H1) Up – ocaml » Stdlib » Ephemeron » K2 » Make » H1The type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash H2 (ocaml.Stdlib.Ephemeron.K2.Make.H2) Up – ocaml » Stdlib » Ephemeron » K2 » Make » H2The type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Make (ocaml.Stdlib.Ephemeron.K2.Make) Up – ocaml » Stdlib » Ephemeron » K2 » MakeModule K2.Make Functor 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.
val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
H1 (ocaml.Stdlib.Ephemeron.K2.MakeSeeded.H1) Up – ocaml » Stdlib » Ephemeron » K2 » MakeSeeded » H1The type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
H2 (ocaml.Stdlib.Ephemeron.K2.MakeSeeded.H2) Up – ocaml » Stdlib » Ephemeron » K2 » MakeSeeded » H2The type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
MakeSeeded (ocaml.Stdlib.Ephemeron.K2.MakeSeeded) Up – ocaml » Stdlib » Ephemeron » K2 » MakeSeededval create : ?random :bool -> int -> 'a t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
K2 (ocaml.Stdlib.Ephemeron.K2) Up – ocaml » Stdlib » Ephemeron » K2an ephemeron with two keys
val make : 'k1 -> 'k2 -> 'd -> ('k1 , 'k2 , 'd ) t val query : ('k1 , 'k2 , 'd ) t -> 'k1 -> 'k2 -> 'd optionFunctor building an implementation of a weak hash table
Functor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded
Bucket (ocaml.Stdlib.Ephemeron.Kn.Bucket) Up – ocaml » Stdlib » Ephemeron » Kn » BucketA bucket is a mutable "list" of ephemerons.
val make : unit -> ('k , 'd ) t val add : ('k , 'd ) t -> 'k array-> 'd -> Add an ephemeron to the bucket.
val remove : ('k , 'd ) t -> 'k array-> remove 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 -> Returns an upper bound on the length of the bucket.
val clear : ('k , 'd ) t -> Remove all ephemerons from the bucket.
H (ocaml.Stdlib.Ephemeron.Kn.Make.H) Up – ocaml » Stdlib » Ephemeron » Kn » Make » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Make (ocaml.Stdlib.Ephemeron.Kn.Make) Up – ocaml » Stdlib » Ephemeron » Kn » MakeModule Kn.Make Functor 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.
val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
H (ocaml.Stdlib.Ephemeron.Kn.MakeSeeded.H) Up – ocaml » Stdlib » Ephemeron » Kn » MakeSeeded » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
MakeSeeded (ocaml.Stdlib.Ephemeron.Kn.MakeSeeded) Up – ocaml » Stdlib » Ephemeron » Kn » MakeSeededval create : ?random :bool -> int -> 'a t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
Kn (ocaml.Stdlib.Ephemeron.Kn) Up – ocaml » Stdlib » Ephemeron » Knan ephemeron with an arbitrary number of keys of the same type
val make : 'k array-> 'd -> ('k , 'd ) t val query : ('k , 'd ) t -> 'k array-> 'd optionFunctor building an implementation of a weak hash table
Functor building an implementation of a weak hash table. The seed is similar to the one of Hashtbl.MakeSeeded
Ephemeron (ocaml.Stdlib.Ephemeron) Up – ocaml » Stdlib » EphemeronModule Stdlib.Ephemeron Ephemerons 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
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:
it is a root value it is reachable from alive value by usual pointers it is the data of an alive ephemeron with all its full keys alive Notes:
Ephemerons are defined in a language agnostic way in this paper: B. Hayes, Ephemerons: A New Finalization Mechanism, OOPSLA'97
Unsynchronized accesses
Unsynchronized accesses to a weak hash table may lead to an invalid weak hash table state. Thus, concurrent accesses to a buffer must be synchronized (for instance with a Mutex.t
module type S = sig ... end The output signature of the functors K1.MakeK2.Make
Ephemerons with two keys.
Ephemerons with arbitrary number of keys of the same type.
S (ocaml.Stdlib.Ephemeron.S) Up – ocaml » Stdlib » Ephemeron » SModule type Ephemeron.S The output signature of the functors K1.MakeK2.Make
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.
val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
SeededS (ocaml.Stdlib.Ephemeron.SeededS) Up – ocaml » Stdlib » Ephemeron » SeededSval create : ?random :bool -> int -> 'a t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> remove all dead bindings. Done automatically during automatic resizing.
Filename (ocaml.Stdlib.Filename) Up – ocaml » Stdlib » Filenameval current_dir_name : stringThe conventional name for the current directory (e.g. . in Unix).
val parent_dir_name : stringThe conventional name for the parent of the current directory (e.g. .. in Unix).
The directory separator (e.g. / in Unix).
val concat : string -> string -> stringconcat dir file returns a file name that designates file file in directory dir.
val is_relative : string -> boolReturn true if the file name is relative to the current directory, false if it is absolute (i.e. in Unix, starts with /).
val is_implicit : string -> boolReturn 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.
val check_suffix : string -> string -> boolcheck_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.
val chop_suffix : string -> string -> stringchop_suffix name suff removes the suffix suff from the filename name.
val chop_suffix_opt : suffix :string -> string -> string option 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.
val extension : string -> stringextension 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.
val remove_extension : string -> stringReturn the given file name without its extension, as defined in Filename.extension
The following invariant holds for any file name s:
remove_extension s ^ extension s = s
val chop_extension : string -> stringval basename : string -> stringSplit 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.chdirbasename 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.
val dirname : string -> stringSee Filename.basenamedirname 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.
val temp_file : ?temp_dir :string -> string -> string -> stringtemp_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_name0o600 (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_channel Same as Filename.temp_filetemp_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).
val temp_dir : ?temp_dir :string -> ?perms :int -> string -> string -> stringtemp_dir prefix suffix creates and returns the name of a fresh temporary directory with permissions perms (defaults to 0o700) inside temp_dir. The base name of the temporary directory 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_name0o700 (readable, writable, and searchable only by the file owner). The directory is guaranteed to be different from any other directory that existed when temp_dir was called.
If temp_dir does not exist, this function does not create it. Instead, it raises Sys_error.
val get_temp_dir_name : unit -> stringThe 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
val set_temp_dir_name : string -> unitval quote : string -> stringReturn 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 -> quote_command cmd args returns a quoted command line, suitable for use as an argument to Sys.commandUnix.systemUnix.open_process
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.quotecmd.exe shell that is called by Sys.command
Array (ocaml.Stdlib.Float.Array) Up – ocaml » Stdlib » Float » ArrayThe type of float arrays with packed representation.
Return 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 -> t make n x returns a fresh floatarray of length n, initialized with x.
create n returns a fresh floatarray of length n, with uninitialized data.
val init : int -> (int -> float) -> t init 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.
Same as append
val sub : t -> int -> int -> t 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.
val blit : t -> int -> t -> int -> int -> unitblit 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 list to_list a returns the list of all the elements of a.
val of_list : float list -> t of_list l returns a fresh floatarray containing the elements of l.
val iter : (float -> unit) -> t -> 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); ().
val iteri : (int -> float -> unit) -> t -> Same as iter
val map : (float -> float) -> t -> t map f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
val map_inplace : (float -> float) -> t -> map_inplace f a applies function f to all elements of a, and updates their values in place.
val mapi : (int -> float -> float) -> t -> t Same as map
val mapi_inplace : (int -> float -> float) -> t -> Same as map_inplace
val fold_left : ('acc -> float -> 'acc ) -> 'acc -> t -> 'acc fold_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 -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold_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.
val iter2 : (float -> float -> unit) -> t -> t -> Array.iter2 f a b applies function f to all the elements of a and b.
val map2 : (float -> float -> float) -> t -> t -> t 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 -> for_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 -> exists 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 -> mem 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 -> Same as mem
val find_opt : (float -> bool) -> t -> float option val find_index : (float -> bool) -> t -> int option find_index f a returns Some i, where i is the index of the first element of the array a that satisfies f x, if there is such an element.
It returns None if there is no such element.
val find_map : (float -> 'a option -> t -> 'a optionval find_mapi : (int -> float -> 'a option -> t -> 'a optionSame as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
val sort : (float -> float -> int) -> t -> Sort 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.comparesort, 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 < 0if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0 When 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 -> Same as sort
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 -> Iterate on the floatarray, in increasing order. Modifications of the floatarray during iteration will be reflected in the sequence.
val to_seqi : t -> (int * float) Seq.t Iterate on the floatarray, in increasing order, yielding indices along elements. Modifications of the floatarray during iteration will be reflected in the sequence.
Create an array from the generator.
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 -> -> 'a array-> t map_from_array f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
Care must be taken when concurrently accessing float arrays from multiple domains: accessing an array will never crash a program, but unsynchronized accesses might yield surprising (non-sequentially-consistent) results.
Every float array operation that accesses more than one array element is not atomic. This includes iteration, scanning, sorting, splitting and combining arrays.
For example, consider the following program:
let size = 100_000_000
+let a = Float.Array.make size 1.
+let update a f () =
+ Float.Array.iteri (fun i x -> Float.Array.set a i (f x)) a
+let d1 = Domain.spawn (update a (fun x -> x +. 1.))
+let d2 = Domain.spawn (update a (fun x -> 2. *. x +. 1.))
+let () = Domain.join d1; Domain.join d2After executing this code, each field of the float array a is either 2., 3., 4. or 5.. If atomicity is required, then the user must implement their own synchronization (for example, using Mutex.t
If two domains only access disjoint parts of the array, then the observed behaviour is the equivalent to some sequential interleaving of the operations from the two domains.
A data race is said to occur when two domains access the same array element without synchronization and at least one of the accesses is a write. In the absence of data races, the observed behaviour is equivalent to some sequential interleaving of the operations from different domains.
Whenever possible, data races should be avoided by using synchronization to mediate the accesses to the array elements.
Indeed, in the presence of data races, programs will not crash but the observed behaviour may not be equivalent to any sequential interleaving of operations from different domains. Nevertheless, even in the presence of data races, a read operation will return the value of some prior write to that location with a few exceptions.
Float arrays have two supplementary caveats in the presence of data races.
First, the blit operation might copy an array byte-by-byte. Data races between such a blit operation and another operation might produce surprising values due to tearing: partial writes interleaved with other operations can create float values that would not exist with a sequential execution.
For instance, at the end of
let zeros = Float.Array.make size 0.
+let max_floats = Float.Array.make size Float.max_float
+let res = Float.Array.copy zeros
+let d1 = Domain.spawn (fun () -> Float.Array.blit zeros 0 res 0 size)
+let d2 = Domain.spawn (fun () -> Float.Array.blit max_floats 0 res 0 size)
+let () = Domain.join d1; Domain.join d2the res float array might contain values that are neither 0. nor max_float.
Second, on 32-bit architectures, getting or setting a field involves two separate memory accesses. In the presence of data races, the user may observe tearing on any operation.
ArrayLabels (ocaml.Stdlib.Float.ArrayLabels) Up – ocaml » Stdlib » Float » ArrayLabelsThe type of float arrays with packed representation.
Return 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 -> t make n x returns a fresh floatarray of length n, initialized with x.
create n returns a fresh floatarray of length n, with uninitialized data.
val init : int -> f :(int -> float) -> t init 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.
Same as append
val sub : t -> pos :int -> len :int -> t 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.
val blit : src :t -> src_pos :int -> dst :t -> dst_pos :int -> len :int -> 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 list to_list a returns the list of all the elements of a.
val of_list : float list -> t of_list l returns a fresh floatarray containing the elements of l.
val iter : f :(float -> unit) -> t -> 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); ().
val iteri : f :(int -> float -> unit) -> t -> Same as iter
val map : f :(float -> float) -> t -> t map ~f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
val map_inplace : f :(float -> float) -> t -> map_inplace f a applies function f to all elements of a, and updates their values in place.
val mapi : f :(int -> float -> float) -> t -> t Same as map
val mapi_inplace : f :(int -> float -> float) -> t -> Same as map_inplace
val fold_left : f :('acc -> float -> 'acc ) -> init :'acc -> t -> 'acc fold_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 -> 'acc -> 'acc ) -> t -> init :'acc -> 'acc fold_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.
val iter2 : f :(float -> float -> unit) -> t -> t -> Array.iter2 ~f a b applies function f to all the elements of a and b.
val map2 : f :(float -> float -> float) -> t -> t -> t 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 -> for_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 -> exists 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 -> mem 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 -> Same as mem
val find_opt : f :(float -> bool) -> t -> float option val find_index : f :(float -> bool) -> t -> int option find_index ~f a returns Some i, where i is the index of the first element of the array a that satisfies f x, if there is such an element.
It returns None if there is no such element.
val find_map : f :(float -> 'a option -> t -> 'a optionval find_mapi : f :(int -> float -> 'a option -> t -> 'a optionSame as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
val sort : cmp :(float -> float -> int) -> t -> Sort 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.comparesort, 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 < 0if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0 When 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 -> Same as sort
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 -> Iterate on the floatarray, in increasing order. Modifications of the floatarray during iteration will be reflected in the sequence.
val to_seqi : t -> (int * float) Seq.t Iterate on the floatarray, in increasing order, yielding indices along elements. Modifications of the floatarray during iteration will be reflected in the sequence.
Create an array from the generator.
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 -> -> 'a array-> t map_from_array ~f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.
Care must be taken when concurrently accessing float arrays from multiple domains: accessing an array will never crash a program, but unsynchronized accesses might yield surprising (non-sequentially-consistent) results.
Every float array operation that accesses more than one array element is not atomic. This includes iteration, scanning, sorting, splitting and combining arrays.
For example, consider the following program:
let size = 100_000_000
+let a = Float.ArrayLabels.make size 1.
+let update a f () =
+ Float.ArrayLabels.iteri ~f:(fun i x -> Float.Array.set a i (f x)) a
+let d1 = Domain.spawn (update a (fun x -> x +. 1.))
+let d2 = Domain.spawn (update a (fun x -> 2. *. x +. 1.))
+let () = Domain.join d1; Domain.join d2After executing this code, each field of the float array a is either 2., 3., 4. or 5.. If atomicity is required, then the user must implement their own synchronization (for example, using Mutex.t
If two domains only access disjoint parts of the array, then the observed behaviour is the equivalent to some sequential interleaving of the operations from the two domains.
A data race is said to occur when two domains access the same array element without synchronization and at least one of the accesses is a write. In the absence of data races, the observed behaviour is equivalent to some sequential interleaving of the operations from different domains.
Whenever possible, data races should be avoided by using synchronization to mediate the accesses to the array elements.
Indeed, in the presence of data races, programs will not crash but the observed behaviour may not be equivalent to any sequential interleaving of operations from different domains. Nevertheless, even in the presence of data races, a read operation will return the value of some prior write to that location with a few exceptions.
Float arrays have two supplementary caveats in the presence of data races.
First, the blit operation might copy an array byte-by-byte. Data races between such a blit operation and another operation might produce surprising values due to tearing: partial writes interleaved with other operations can create float values that would not exist with a sequential execution.
For instance, at the end of
let zeros = Float.Array.make size 0.
+let max_floats = Float.Array.make size Float.max_float
+let res = Float.Array.copy zeros
+let d1 = Domain.spawn (fun () -> Float.Array.blit zeros 0 res 0 size)
+let d2 = Domain.spawn (fun () -> Float.Array.blit max_floats 0 res 0 size)
+let () = Domain.join d1; Domain.join d2the res float array might contain values that are neither 0. nor max_float.
Second, on 32-bit architectures, getting or setting a field involves two separate memory accesses. In the presence of data races, the user may observe tearing on any operation.
Float (ocaml.Stdlib.Float) Up – ocaml » Stdlib » FloatModule Stdlib.Float Floating-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, ...
val add : float -> float -> floatval sub : float -> float -> floatFloating-point subtraction.
val mul : float -> float -> floatFloating-point multiplication.
val div : float -> float -> floatval fma : float -> float -> float -> floatfma 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.
val rem : float -> float -> floatrem 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.
val succ : float -> floatsucc x returns the floating point number right after x i.e., the smallest floating-point number greater than x. See also next_after
val pred : float -> floatpred x returns the floating-point number right before x i.e., the greatest floating-point number smaller than x. See also next_after
abs f returns the absolute value of f.
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, unless otherwise specified in IEEE 754 standard. As for floating-point comparisons, =, <, <=, > and >= return false and <> returns true if one or both of their arguments is nan.
nan is quiet_nan since 5.1; it was a signaling NaN before.
val signaling_nan : floatSignaling NaN. The corresponding signals do not raise OCaml exception, but the value can be useful for interoperability with C libraries.
The largest positive finite value of type float.
The smallest positive, non-zero, non-denormalized value of type float.
The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0.
val is_finite : float -> boolis_finite x is true if and only if x is finite i.e., not infinite and not nan
val is_infinite : float -> boolval is_nan : float -> boolis_nan x is true if and only if x is not a number (see nan
val is_integer : float -> boolis_integer x is true if and only if x is an integer.
val of_int : int -> floatConvert an integer to floating-point.
val to_int : float -> intTruncate 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.
val of_string : string -> floatConvert 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.
val of_string_opt : string -> float option Same as of_string, but returns None instead of raising.
val to_string : float -> stringReturn 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 = | FP_normal Normal number, none of the below
| FP_subnormal Number very close to 0.0, has reduced precision
| FP_zero | FP_infinite Number is positive or negative infinity
| FP_nan Not a number: result of an undefined operation
The five classes of floating-point numbers, as determined by the classify_float
val classify_float : float -> fpclass Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
val pow : float -> float -> floatval sqrt : float -> floatval cbrt : float -> floatval exp2 : float -> floatBase 2 exponential function.
val log10 : float -> floatval log2 : float -> floatval expm1 : float -> floatexpm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.
val log1p : float -> floatlog1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.
Cosine. Argument is in radians.
Sine. Argument is in radians.
Tangent. Argument is in radians.
val acos : float -> floatArc cosine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between 0.0 and pi.
val asin : float -> floatArc sine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between -pi/2 and pi/2.
val atan : float -> floatArc tangent. Result is in radians and is between -pi/2 and pi/2.
val atan2 : float -> float -> floatatan2 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.
val hypot : float -> float -> floathypot 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.
val cosh : float -> floatHyperbolic cosine. Argument is in radians.
val sinh : float -> floatHyperbolic sine. Argument is in radians.
val tanh : float -> floatHyperbolic tangent. Argument is in radians.
val acosh : float -> floatHyperbolic arc cosine. The argument must fall within the range [1.0, inf]. Result is in radians and is between 0.0 and inf.
val asinh : float -> floatHyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
val atanh : float -> floatHyperbolic 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].
val erfc : float -> floatComplementary error function (erfc x = 1 - erf x). The argument ranges over the entire real line. The result is always within [-1.0, 1.0].
val trunc : float -> floattrunc x rounds x to the nearest integer whose absolute value is less than or equal to x.
val round : float -> floatround 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.
val ceil : float -> floatRound 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.
val floor : float -> floatRound 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.
val next_after : float -> float -> floatnext_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.
val copy_sign : float -> float -> floatcopy_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.
val sign_bit : float -> boolsign_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.
val frexp : float -> float * intfrexp 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.
val ldexp : float -> int -> floatldexp x n returns x *. 2 ** n.
val modf : float -> float * floatmodf f returns the pair of the fractional and integral part of f.
An alias for the type of floating-point numbers.
val compare : t -> t -> 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.
val equal : t -> t -> The equal function for floating-point numbers, compared using compare
min x y returns the minimum of x and y. It returns nan when x or y is nan. Moreover min (-0.) (+0.) = -0.
val max : float -> float -> floatmax x y returns the maximum of x and y. It returns nan when x or y is nan. Moreover max (-0.) (+0.) = +0.
val min_max : float -> float -> float * floatmin_max x y is (min x y, max x y), just more efficient.
val min_num : t -> t -> t 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.
val max_num : t -> t -> t 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.
val min_max_num : float -> float -> float * floatmin_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 seeded_hash : int -> t -> An unseeded hash function for floats, with the same output value as Hashtbl.hashHashtbl.Make
module Array : sig ... end Float arrays with packed representation.
Float arrays with packed representation (labeled functions).
Format (ocaml.Stdlib.Format) Up – ocaml » Stdlib » FormatModule Stdlib.Format Pretty-printing.
If you are new to this module, see the examples below.
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:
Most functions in the Formatget_std_formatterpp_ that takes a formatter as its first argument. For the version that operates on the current domain's standard formatter, the call to get_std_formatter
More formatters can be created with formatter_of_out_channelformatter_of_bufferformatter_of_symbolic_output_buffercustom formatters .
Warning : Since formatters contain mutable state, it is not thread-safe to use the same formatter on multiple domains in parallel without synchronization.
If multiple domains write to the same output channel using the predefined formatters (as obtained by get_std_formatterget_err_formatterprint_flushformatter_of_out_channel
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:
use simple pretty-printing boxes (as obtained by open_box 0); use simple break hints as obtained by print_cut () that outputs a simple break hint, or by print_space () that outputs a space indicating a break hint; once a pretty-printing box is open, display its material with basic printing functions (e. g. print_int and print_string); when the material for a pretty-printing box has been printed, call close_box () to close the box; at the end of pretty-printing, flush the pretty-printer to display all the remaining material, e.g. evaluate 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
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:
within an horizontal box, break hints never split the line (but the line may be split in a box nested deeper), within a vertical box, break hints always split the line, within an horizontal/vertical box, if the box fits on the current line then break hints never split the line, otherwise break hint always split the line, within a compacting box, a break hint never splits the line, unless there is no more room on the current line. 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 open_box : 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 close_box : unit -> unitCloses the most recently open pretty-printing box.
val open_hbox : 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 open_vbox : 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 open_hvbox : 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 -> unitval open_hovbox : 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 print_string : string -> unitpp_print_string ppf s prints s in the current pretty-printing box.
val pp_print_bytes : formatter -> bytes -> unitval print_bytes : bytes -> unitpp_print_bytes ppf b prints b in the current pretty-printing box.
val pp_print_as : formatter -> int -> string -> unitval print_as : 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 print_int : int -> unitPrint an integer in the current pretty-printing box.
val pp_print_float : formatter -> float -> unitval print_float : float -> unitPrint a floating point number in the current pretty-printing box.
val pp_print_char : formatter -> char -> unitval print_char : char -> unitPrint a character in the current pretty-printing box.
val pp_print_bool : formatter -> bool -> unitval print_bool : bool -> unitPrint a boolean in the current pretty-printing box.
A '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:
the 'space': output a space or split the line if appropriate, the 'cut': split the line if appropriate. 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 -> unitval print_space : 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 print_cut : 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 -> unitval print_break : 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) -> pp_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 -> unitval force_newline : 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 -> unitval print_if_newline : 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 -> unitval print_flush : 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
val pp_print_newline : formatter -> unit -> unitval print_newline : 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_flushprint_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 set_margin : 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 get_margin : unit -> intReturns the position of the right margin.
val pp_set_max_indent : formatter -> int -> unitval set_max_indent : 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 -> intval get_max_indent : unit -> intReturn the maximum indentation limit (in characters).
Geometric functions can be used to manipulate simultaneously the coupled variables, margin and maximum indentation limit.
type geometry = { max_indent : int; margin : int; } Check if the formatter geometry is valid: 1 < max_indent < margin
val pp_set_geometry : formatter -> max_indent :int -> margin :int -> val set_geometry : max_indent :int -> margin :int -> val pp_safe_set_geometry : formatter -> max_indent :int -> margin :int -> val safe_set_geometry : max_indent :int -> margin :int -> pp_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
Return 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 -> unitval set_max_boxes : 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 -> intval get_max_boxes : unit -> intReturns the maximum number of pretty-printing boxes allowed before ellipsis.
val pp_over_max_boxes : formatter -> unit -> boolval over_max_boxes : 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 open_tbox : 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
A tabulation box features specific tabulation breaks to move to next tabulation marker or split the line. Function Format.print_tbreak
val pp_close_tbox : formatter -> unit -> unitval close_tbox : unit -> unitCloses the most recently opened tabulation box.
val set_tab : unit -> unitSets a tabulation marker at current insertion point.
val print_tab : 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 -> unitval print_tbreak : 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 -> unitval set_ellipsis_text : 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 -> stringval get_ellipsis_text : unit -> stringReturn the text of the ellipsis.
Semantic 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_stagpp_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 :
The tag-marking operation is the simpler tag specific operation: it simply writes a tag specific string into the output device of the formatter. Tag-marking does not interfere with line-splitting computation. The tag-printing operation is the more involved tag specific operation: it can print arbitrary material to the formatter. Tag-printing is tightly linked to the current pretty-printer operations. 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:
Tag-printing a semantic tag means calling the formatter specific function 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). Tag-marking a semantic tag means calling the formatter specific function 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_tagsset_mark_tagsset_print_tags
type stag += | String_tag of tag String_tag s is a string tag s. String tags can be inserted either by explicitly using the constructor String_tag or by using the dedicated format syntax "@{<s> ... @}".
val open_stag : stag -> pp_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 -> unitval close_stag : 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.
pp_set_tags ppf b turns on or off the treatment of semantic tags (default is off).
pp_set_print_tags ppf b turns on or off the tag-printing operations.
pp_set_mark_tags ppf b turns on or off the tag-marking operations.
Return the current status of tag-printing operations.
Return the current status of tag-marking operations.
Redirecting the standard formatter output
Redirect 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_channelstd_formatter.
pp_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).
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!
The set of output functions specific to a formatter:
the 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. the 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.the 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. the 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:
fields out_string and out_flush are output device specific; (e.g. Stdlib.output_stringStdlib.flushStdlib.out_channelBuffer.add_substring and Stdlib.ignoreBuffer.t output device), field out_newline is equivalent to out_string "\n" 0 1; fields out_spaces and out_indent are equivalent to out_string (String.make n ' ') 0 n. pp_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.
Return the current output functions of the pretty-printer, including line splitting and indentation functions. Useful to record the current setting and restore it afterwards.
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.
pp_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.
Return 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.tb, formatter_of_bufferb returns a new formatter using buffer b as its output device. Similarly, given a Stdlib.out_channeloc, formatter_of_out_channeloc 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_functionsout_funs computes a new formatter using those functions for output.
formatter_of_out_channel oc returns a new formatter writing to the corresponding output channel oc.
synchronized_formatter_of_out_channel oc returns the key to the domain-local state that holds the domain-local formatter for writing to the corresponding output channel oc.
When the formatter is used with multiple domains, the output from the domains will be interleaved with each other at points where the formatter is flushed, such as with print_flush
get_std_formatter () returns the current domain's standard formatter used to write to standard output.
get_err_formatter () returns the current domain's formatter used to write to standard error.
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_flushpp_print_newline
The initial domain's string buffer in which str_formatter writes.
get_stdbuf () returns the current domain's string buffer in which the current domain's string formatter writes.
The current domain's formatter to output to the current domains string buffer.
Returns the material printed with str_formatter of the current domain, flushes the formatter and resets the corresponding buffer.
make_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_channeloc.
make_synchronized_formatter out flush returns the key to the domain-local state that holds the domain-local formatter that outputs with function out, and flushes with function flush.
When the formatter is used with multiple domains, the output from the domains will be interleaved with each other at points where the formatter is flushed, such as with print_flush
formatter_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_functionsout_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_flush | Output_newline | 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
type symbolic_output_bufferThe output buffer of a symbolic pretty-printer.
make_symbolic_output_buffer () returns a fresh buffer for symbolic output.
clear_symbolic_output_buffer sob resets buffer sob.
get_symbolic_output_buffer sob returns the contents of buffer sob.
flush_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
add_symbolic_output_item sob itm adds item itm to buffer sob.
formatter_of_symbolic_output_buffer sob returns a symbolic formatter that outputs to symbolic_output_buffer sob.
val pp_print_iter :
+ ?pp_sep :(formatter -> unit -> unit) -> (('a -> -> 'b -> -> (formatter -> 'a -> -> formatter -> 'b -> pp_print_iter ~pp_sep iter pp_v ppf v formats on ppf the iterations of iter over a collection v of values using pp_v. Iterations are separated by pp_sep (defaults to pp_print_cut
pp_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
pp_print_array ?pp_sep pp_v ppf a prints items of array a, using pp_v to print each item, and calling pp_sep between items (pp_sep defaults to pp_print_cut
If a is mutated after pp_print_array is called, the printed values may not be what is expected because Format can delay the printing. This can be avoided by flushing ppf.
pp_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
This function does not terminate on infinite sequences.
val pp_print_text : formatter -> string -> 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.
pp_print_result ~ok ~error ppf r prints r on ppf using ok if r is Ok _ and error if r is Error _.
pp_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 PrintfFormat 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 full 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_stagclose_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.
Same as fprintf above, but output on get_std_formatter ().
It is defined similarly to fun fmt -> fprintf (get_std_formatter ()) fmt but delays calling get_std_formatter until after the final argument required by the format is received. When used with multiple domains, the output from the domains will be interleaved with each other at points where the formatter is flushed, such as with print_flush
Same as fprintf above, but output on get_err_formatter ().
It is defined similarly to fun fmt -> fprintf (get_err_formatter ()) fmt but delays calling get_err_formatter until after the final argument required by the format is received. When used with multiple domains, the output from the domains will be interleaved with each other at points where the formatter is flushed, such as with print_flush
val sprintf : ('a , unit, string) format -> 'a Same 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. Note that if your format string contains a %a, you should use asprintf.
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 fprintfdprintf "..." 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 asprintfasprintfdprintf
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
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 -> 'b Same 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.
A few warmup examples to get an idea of how Format is used.
We have a list l of pairs (int * bool), which the toplevel prints for us:
# let l = List.init 20 (fun n -> n, n mod 2 = 0)
+val l : (int * bool) list =
+[(0, true); (1, false); (2, true); (3, false); (4, true); (5, false);
+ (6, true); (7, false); (8, true); (9, false); (10, true); (11, false);
+ (12, true); (13, false); (14, true); (15, false); (16, true); (17, false);
+ (18, true); (19, false)]If we want to print it ourself without the toplevel magic, we can try this:
# let pp_pair out (x,y) = Format.fprintf out "(%d, %b)" x y
+val pp_pair : Format.formatter -> int * bool -> unit = <fun>
+# Format.printf "l: [@[<hov>%a@]]@."
+ Format.(pp_print_list ~pp_sep:(fun out () -> fprintf out ";@ ") pp_pair) l
+ l: [(0, true); (1, false); (2, true); (3, false); (4, true); (5, false);
+ (6, true); (7, false); (8, true); (9, false); (10, true); (11, false);
+ (12, true); (13, false); (14, true); (15, false); (16, true);
+ (17, false); (18, true); (19, false)]What this does, briefly, is:
pp_pair prints a pair bool*int surrounded in "(" ")". It takes a formatter (into which formatting happens), and the pair itself. When printing is done it returns ().Format.printf "l = [@[<hov>%a@]]@." ... l is like printf, but with additional formatting instructions (denoted with "@"). The pair "@<hov>" and "@" is a "horizontal-or-vertical box"."@." ends formatting with a newline. It is similar to "\n" but is also aware of the Format.formatter's state. Do not use "\n" with Format. "%a" is a formatting instruction, like "%d" or "%s" for printf. However, where "%d" prints an integer and "%s" prints a string, "%a" takes a printer (of type Format.formatter -> 'a -> unit) and a value (of type 'a) and applies the printer to the value. This is key to compositionality of printers. We build a list printer using Format.pp_print_list ~pp_sep:(...) pp_pair. pp_print_list takes an element printer and returns a list printer. The ?pp_sep optional argument, if provided, is called in between each element to print a separator. Here, for a separator, we use (fun out () -> Format.fprintf out ";@ "). It prints ";", and then "@ " which is a breaking space (either it prints " ", or it prints a newline if the box is about to overflow). This "@ " is responsible for the list printing splitting into several lines. If we omit "@ ", we get an ugly single-line print:
# Format.printf "l: [@[<hov>%a@]]@."
+ Format.(pp_print_list ~pp_sep:(fun out () -> fprintf out "; ") pp_pair) l
+ l: [(0, true); (1, false); (2, true); (* ... *); (18, true); (19, false)]
+- : unit = ()Generally, it is good practice to define custom printers for important types in your program. If, for example, you were to define basic geometry types like so:
type point = {
+ x: float;
+ y: float;
+}
+
+type rectangle = {
+ ll: point; (* lower left *)
+ ur: point; (* upper right *)
+}For debugging purpose, or to display information in logs, or on the console, it would be convenient to define printers for these types. Here is an example of to do it. Note that "%.3f" is a float printer up to 3 digits of precision after the dot; "%f" would print as many digits as required, which is somewhat verbose; "%h" is an hexadecimal float printer.
let pp_point out (p:point) =
+ Format.fprintf out "{ @[x=%.3f;@ y=%.3f@] }" p.x p.y
+
+let pp_rectangle out (r:rectangle) =
+ Format.fprintf out "{ @[ll=%a;@ ur=%a@] }"
+ pp_point r.ll pp_point r.urIn the .mli file, we could have:
val pp_point : Format.formatter -> point -> unit
+
+val pp_rectangle : Format.formatter -> rectangle -> unitThese printers can now be used with "%a" inside other printers.
# Format.printf "some rectangle: %a@."
+ (Format.pp_print_option pp_rectangle)
+ (Some {ll={x=1.; y=2.}; ur={x=42.; y=500.12345}})
+some rectangle: { l={ x=1.000; y=2.000 }; ur={ x=42.000; y=500.123 } }
+
+# Format.printf "no rectangle: %a@."
+ (Format.pp_option pp_rectangle)
+ None
+no rectangle:See how we combine pp_print_option (option printer) and our newly defined rectangle printer, like we did with pp_print_list earlier.
For a more extensive tutorial, see "Using the Format module" .
A final note: the Format module is a starting point. The OCaml ecosystem has libraries that makes formatting easier and more expressive, with more combinators, more concise names, etc. An example of such a library is Fmt .
Automatic deriving of pretty-printers from type definitions is also possible, using https://github.com/ocaml-ppx/ppx_deriving or similar ppx derivers.
Fun (ocaml.Stdlib.Fun) Up – ocaml » Stdlib » FunModule Stdlib.Fun Function manipulation.
id is the identity function. For any argument x, id x is x.
val const : 'a -> _ -> 'a const c is a function that always returns the value c. For any argument x, (const c) x is c.
val flip : ('a -> 'b -> 'c ) -> 'b -> 'a -> '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.
val negate : ('a -> -> 'a -> negate p is the negation of the predicate function p. For any argument x, (negate p) x is not (p x).
val protect : finally :(unit -> unit) -> (unit -> 'a ) -> 'a 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
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_memoryStdlib.Stack_overflowSys.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 Finally_raised of exnFinally_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.
Memprof (ocaml.Stdlib.Gc.Memprof) Up – ocaml » Stdlib » Gc » MemprofModule Gc.Memprof Memprof 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_source = | Normal | Marshal | Custom 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 -> dealloc_major : 'major -> } 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 ) tracker Default callbacks simply return None or ()
val start :
+ sampling_rate :float -> ?callstack_size :int -> ('minor , 'major ) tracker -> Start 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.
Gc (ocaml.Stdlib.Gc) Up – ocaml » Stdlib » Gctype 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. This metrics is currently not available in OCaml 5: the field value is always 0.
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_majorGc.compactGc.full_majorGc.finaliseGc.finalise_lastGc.full_major
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. This metrics is currently not available in OCaml 5: the field value is always 0.
largest_free : int; Size (in words) of the largest block in the free list. This metrics is currently not available in OCaml 5: the field value is always 0.
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. This metrics is currently not available in OCaml 5: the field value is always 0.
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. These counters give values for the whole program.
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 = { minor_heap_size : int; The size (in words) of the minor heap. Changing this parameter will trigger a minor collection. The total size of the minor heap used by this program is the sum of the heap sizes of the active domains. Default: 256k.
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.
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.
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.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.
stack_limit : int; The maximum size of the fiber stacks (in words). Default: 1024k.
allocation_policy : int; The policy used for allocating in the major heap. Possible values are 0, 1 and 2.
0 is the next-fit policy, which is usually fast but can result in fragmentation, increasing memory consumption. 1 is the first-fit policy, which avoids fragmentation but has corner cases (in certain realistic workloads) where it is sensibly slower. 2 is the best-fit policy, which is fast and avoids fragmentation. In our experiments it is faster and uses less memory than both next-fit and first-fit. (since OCaml 4.10) 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. Custom values that hold more than this many bytes are allocated on the major heap. Note: this only applies to values allocated with caml_alloc_custom_mem (e.g. bigarrays). Default: 70000 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.
Return the current values of the memory management counters in a stat record that represent the program's total memory stats. This function causes a full major collection.
val quick_stat : unit -> stat Same as stat except that live_words, live_blocks, free_words, free_blocks, largest_free, and fragments are set to 0. Due to per-domain buffers it may only represent the state of the program's total memory usage since the last minor collection. This function is much faster than stat because it does not need to trigger a full major collection.
val counters : unit -> float * float * floatReturn (minor_words, promoted_words, major_words) for the current domain or potentially previous domains. This function is as fast as quick_stat.
val minor_words : unit -> floatNumber of words allocated in the minor heap by this domain or potentially previous domains. 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.
Return the current values of the GC parameters in a control record.
set r changes the GC parameters according to the control record r. The normal usage is: Gc.set { (Gc.get()) with Gc.verbose = 0x00d }
Trigger a minor collection.
val major_slice : int -> intmajor_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 and finish the current major collection cycle.
val full_major : unit -> unitDo a minor collection, finish the current major collection cycle, and perform a complete new cycle. This will collect all currently unreachable blocks.
val compact : unit -> unitPerform a full major collection and compact the heap. Note that heap compaction is a lengthy operation.
Print the current values of the memory management counters (in human-readable form) of the total program into the channel argument.
val allocated_bytes : unit -> floatReturn the number of bytes allocated by this domain and potentially a previous domain. It is returned as a float to avoid overflow problems with int on 32-bit machines.
val get_minor_free : unit -> intReturn the current size of the free space inside the minor heap of this domain.
val finalise : ('a -> -> 'a -> 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.makeBytes.makeBytes.createArray.makeStdlib.ref0.
val finalise_last : (unit -> unit) -> 'a -> same as finalisefinalisefinalisefinalise_last
val finalise_release : unit -> unitA 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) -> alarm create_alarm f will arrange for f to be called at the end of each major GC cycle, not caused by f itself, 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 -> delete_alarm a will stop the calls to the function associated to a. Calling delete_alarm a again has no effect.
val eventlog_pause : unit -> unitval eventlog_resume : unit -> unitMemprof 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.
H (ocaml.Stdlib.Hashtbl.Make.H) Up – ocaml » Stdlib » Hashtbl » Make » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Make (ocaml.Stdlib.Hashtbl.Make) Up – ocaml » Stdlib » Hashtbl » MakeModule Hashtbl.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.
val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> H (ocaml.Stdlib.Hashtbl.MakeSeeded.H) Up – ocaml » Stdlib » Hashtbl » MakeSeeded » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
MakeSeeded (ocaml.Stdlib.Hashtbl.MakeSeeded) Up – ocaml » Stdlib » Hashtbl » MakeSeededModule Hashtbl.MakeSeeded Functor 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
val create : ?random :bool -> int -> 'a t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> Hashtbl (ocaml.Stdlib.Hashtbl) Up – ocaml » Stdlib » HashtblModule Stdlib.Hashtbl Hash tables and hash functions.
Hash tables are hashed association tables, with in-place modification. Because most operations on a hash table modify their input, they're more commonly used in imperative code. The lookup of the value associated with a key (see findfind_optMap
The functors MakeMakeSeeded
Warning a hash table is only as good as the hash function. A bad hash function will turn the table into a degenerate association list, with linear time lookup instead of constant time lookup.
The polymorphic thash(=).
See the examples section .
Unsynchronized accesses
Unsynchronized accesses to a hash table may lead to an invalid hash table state. Thus, concurrent accesses to a hash tables must be synchronized (for instance with a Mutex.t
The type of hash tables from type 'a to type 'b.
val create : ?random :bool -> int -> ('a , 'b ) t Hashtbl.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
A hash table that is created with ~random set to true uses the seeded hash function seeded_hash2^{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 folditer
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 randomizeR flag in the OCAMLRUNPARAM environment variable.
val clear : ('a , 'b ) t -> Empty 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 -> Empty a hash table and shrink the size of the bucket table to its initial size.
val copy : ('a , 'b ) t -> ('a , 'b ) t Return a copy of the given hashtable.
val add : ('a , 'b ) t -> 'a -> 'b -> Hashtbl.add tbl key data adds a binding of key to data in table tbl.
Warning : 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.)
If you desire the classic behavior of replacing elements, see replace
val find : ('a , 'b ) t -> 'a -> 'b Hashtbl.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 -> Hashtbl.mem tbl x checks if x is bound in tbl.
val remove : ('a , 'b ) t -> 'a -> Hashtbl.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 -> Hashtbl.replace tbl key data replaces the current binding of key in tbl by a binding of key to data. If key is unbound in tbl, a binding of key to data is added to tbl. This is functionally equivalent to remove tbl key followed by add tbl key data.
val iter : ('a -> 'b -> -> ('a , 'b ) t -> Hashtbl.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 -> Hashtbl.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
val fold : ('a -> 'b -> 'acc -> 'acc ) -> ('a , 'b ) t -> 'acc -> 'acc Hashtbl.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 -> Hashtbl.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.
val randomize : unit -> unitAfter a call to Hashtbl.randomize(), hash tables are created in randomized mode by default: create~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 createHashtbl.randomize() at initialization time before any domains are created.
Note that once Hashtbl.randomize() was called, there is no way to revert to the non-randomized default behavior of createHashtbl.create ~random:false.
val is_randomized : unit -> boolReturn true if the tables are currently created in randomized mode by default, false otherwise.
val rebuild : ?random :bool -> ('a , 'b ) t -> ('a , 'b ) t Return a copy of the given hashtable. Unlike copyrebuild 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
rebuildHashtblrebuildHashtbl
type statistics = { num_bindings : int; Number of bindings present in the table. Same value as returned by length
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.
} Hashtbl.stats tbl returns statistics about the table tbl: number of buckets, size of the biggest bucket, distribution of buckets by size.
val to_seq : ('a , 'b ) t -> ('a * 'b ) Seq.t 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.
val to_seq_keys : ('a , _ ) t -> 'a Seq.t Same as Seq.map fst (to_seq m)
val to_seq_values : (_ , 'b ) t -> 'b Seq.t Same as Seq.map snd (to_seq m)
val add_seq : ('a , 'b ) t -> ('a * 'b ) Seq.t -> Add the given bindings to the table, using add
val replace_seq : ('a , 'b ) t -> ('a * 'b ) Seq.t -> Add the given bindings to the table, using replace
val of_seq : ('a * 'b ) Seq.t -> ('a , 'b ) t Build a table from the given bindings. The bindings are added in the same order they appear in the sequence, using replace_seq
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.
The input signature of the functor Make
module type S = sig ... end The output 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.
Functor 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.
val seeded_hash : int -> 'a -> A variant of hash
val hash_param : int -> int -> 'a -> 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, hashseeded_hashmeaningful = 10 and total = 100.
val seeded_hash_param : int -> int -> int -> 'a -> A variant of hash_paramHashtbl.seeded_hash_param meaningful total seed x.
(* 0...99 *)
+let seq = Seq.ints 0 |> Seq.take 100
+
+(* build from Seq.t *)
+# let tbl =
+ seq
+ |> Seq.map (fun x -> x, string_of_int x)
+ |> Hashtbl.of_seq
+val tbl : (int, string) Hashtbl.t = <abstr>
+
+# Hashtbl.length tbl
+- : int = 100
+
+# Hashtbl.find_opt tbl 32
+- : string option = Some "32"
+
+# Hashtbl.find_opt tbl 166
+- : string option = None
+
+# Hashtbl.replace tbl 166 "one six six"
+- : unit = ()
+
+# Hashtbl.find_opt tbl 166
+- : string option = Some "one six six"
+
+# Hashtbl.length tbl
+- : int = 101Given a sequence of elements (here, a Seq.t
Here we illustrate that principle using a sequence of (ascii) characters (type char). We use a custom Char_tbl specialized for char.
# module Char_tbl = Hashtbl.Make(struct
+ type t = char
+ let equal = Char.equal
+ let hash = Hashtbl.hash
+ end)
+
+(* count distinct occurrences of chars in [seq] *)
+# let count_chars (seq : char Seq.t) : _ list =
+ let counts = Char_tbl.create 16 in
+ Seq.iter
+ (fun c ->
+ let count_c =
+ Char_tbl.find_opt counts c
+ |> Option.value ~default:0
+ in
+ Char_tbl.replace counts c (count_c + 1))
+ seq;
+ (* turn into a list *)
+ Char_tbl.fold (fun c n l -> (c,n) :: l) counts []
+ |> List.sort (fun (c1,_)(c2,_) -> Char.compare c1 c2)
+val count_chars : Char_tbl.key Seq.t -> (Char.t * int) list = <fun>
+
+(* basic seq from a string *)
+# let seq = String.to_seq "hello world, and all the camels in it!"
+val seq : char Seq.t = <fun>
+
+# count_chars seq
+- : (Char.t * int) list =
+[(' ', 7); ('!', 1); (',', 1); ('a', 3); ('c', 1); ('d', 2); ('e', 3);
+ ('h', 2); ('i', 2); ('l', 6); ('m', 1); ('n', 2); ('o', 2); ('r', 1);
+ ('s', 1); ('t', 2); ('w', 1)]
+
+(* "abcabcabc..." *)
+# let seq2 =
+ Seq.cycle (String.to_seq "abc") |> Seq.take 31
+val seq2 : char Seq.t = <fun>
+
+# String.of_seq seq2
+- : String.t = "abcabcabcabcabcabcabcabcabcabca"
+
+# count_chars seq2
+- : (Char.t * int) list = [('a', 11); ('b', 10); ('c', 10)]HashedType (ocaml.Stdlib.Hashtbl.HashedType) Up – ocaml » Stdlib » Hashtbl » HashedTypeThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash S (ocaml.Stdlib.Hashtbl.S) Up – ocaml » Stdlib » Hashtbl » Sval add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> SeededHashedType (ocaml.Stdlib.Hashtbl.SeededHashedType) Up – ocaml » Stdlib » Hashtbl » SeededHashedTypeThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
SeededS (ocaml.Stdlib.Hashtbl.SeededS) Up – ocaml » Stdlib » Hashtbl » SeededSval create : ?random :bool -> int -> 'a t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> In_channel (ocaml.Stdlib.In_channel) Up – ocaml » Stdlib » In_channelThe type of input channel.
type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append open for appending: always write at end of file.
| Open_creat create the file if it does not exist.
| Open_trunc empty the file if it already exists.
| Open_excl fail if Open_creat and the file already exists.
| Open_binary open in binary mode (no conversion).
| Open_text open in text mode (may perform conversions).
| Open_nonblock open in non-blocking mode.
The standard input for the process.
val open_bin : string -> t Open 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 -> t Same as open_binopen_bin
val open_gen : open_flag list-> int -> string -> t open_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. open_textopen_bin
val with_open_bin : string -> (t -> 'a ) -> 'a with_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 ) -> 'a val with_open_gen : open_flag list-> int -> string -> (t -> 'a ) -> 'a Like with_open_binopen_gen
Close the given channel. Input functions raise a Sys_error exception when they are applied to a closed input channel, except close
val close_noerr : t -> Same as close
Read one character from the given input channel. Returns None if there are no more characters to read.
Same as input_charNone if the end of file was reached.
input_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.win32true in which case it is the sequence of characters \r\n.
really_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.
If the same channel is read concurrently by multiple threads, the returned string is not guaranteed to contain contiguous characters from the input.
input_all ic reads all remaining data from ic.
If the same channel is read concurrently by multiple threads, the returned string is not guaranteed to contain contiguous characters from the input.
input_lines ic reads lines using input_line
input 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_inputlen characters.
really_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.
If the same channel is read concurrently by multiple threads, the bytes read by really_input are not guaranteed to be contiguous.
val fold_lines : ('acc -> string -> 'acc ) -> 'acc -> t -> 'acc fold_lines f init ic reads lines from ic using input_linef in the style of a fold. More precisely, if lines l1, ..., lN are read, fold_lines f init ic computes f (... (f (f init l1) l2) ...) lN. If f has no side effects, this is equivalent to List.fold_left f init (In_channel.input_lines ic), but is more efficient since it does not construct the list of all lines read.
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.
Return 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 posseek
Return 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 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.
isatty ic is true if ic refers to a terminal or console window, false otherwise.
Reading the contents of a file:
let read_file file = In_channel.with_open_bin file In_channel.input_allReading a line from stdin:
let user_input () = In_channel.input_line In_channel.stdinInt (ocaml.Stdlib.Int) Up – ocaml » Stdlib » IntThe type for integer values.
minus_one is the integer -1.
val add : int -> int -> intadd x y is the addition x + y.
val sub : int -> int -> intsub x y is the subtraction x - y.
val mul : int -> int -> intmul x y is the multiplication x * y.
val div : int -> int -> intdiv x y is the division x / y. See Stdlib.(/)
val rem : int -> int -> intrem x y is the remainder x mod y. See Stdlib.(mod)
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
max_int is the greatest representable integer, 2{^[Sys.int_size - 1]} - 1.
min_int is the smallest representable integer, -2{^[Sys.int_size - 1]}.
val logand : int -> int -> intlogand x y is the bitwise logical and of x and y.
val logor : int -> int -> intlogor x y is the bitwise logical or of x and y.
val logxor : int -> int -> intlogxor x y is the bitwise logical exclusive or of x and y.
lognot x is the bitwise logical negation of x.
val shift_left : int -> int -> intshift_left x n shifts x to the left by n bits. The result is unspecified if n < 0 or n > Sys.int_size
val shift_right : int -> int -> intshift_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
val shift_right_logical : int -> int -> intshift_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
val equal : int -> int -> boolequal x y is true if and only if x = y.
val compare : int -> int -> intval min : int -> int -> intReturn the smaller of the two arguments.
val max : int -> int -> intReturn the greater of the two arguments.
val to_float : int -> floatto_float x is x as a floating point number.
val of_float : float -> intof_float x truncates x to an integer. The result is unspecified if the argument is nan or falls outside the range of representable integers.
val to_string : int -> stringto_string x is the written representation of x in decimal.
val seeded_hash : int -> int -> intAn unseeded hash function for ints, with the same output value as Hashtbl.hashHashtbl.Make
Int32 (ocaml.Stdlib.Int32) Up – ocaml » Stdlib » Int32Module Stdlib.Int32 32-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 = -1lval add : int32 -> int32 -> int32val sub : int32 -> int32 -> int32val mul : int32 -> int32 -> int32val div : int32 -> int32 -> int32Integer division. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/)
val unsigned_div : int32 -> int32 -> int32Same as divunsigned 32-bit integers.
val rem : int32 -> int32 -> int32Integer 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.
val unsigned_rem : int32 -> int32 -> int32Same as remunsigned 32-bit integers.
val succ : int32 -> int32Successor. Int32.succ x is Int32.add x Int32.one.
val pred : int32 -> int32Predecessor. Int32.pred x is Int32.sub x Int32.one.
abs x is the absolute value of x. On min_int this is min_int itself and thus remains negative.
The greatest representable 32-bit integer, 231 - 1.
The smallest representable 32-bit integer, -231 .
val logand : int32 -> int32 -> int32val logor : int32 -> int32 -> int32val logxor : int32 -> int32 -> int32Bitwise logical exclusive or.
val lognot : int32 -> int32Bitwise logical negation.
val shift_left : int32 -> int -> int32Int32.shift_left x y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= 32.
val shift_right : int32 -> int -> int32Int32.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.
val shift_right_logical : int32 -> int -> int32Int32.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.
val of_int : int -> int32Convert the given integer (type int) to a 32-bit integer (type int32). On 64-bit platforms, the argument is taken modulo 232 .
val to_int : int32 -> intConvert 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.
val unsigned_to_int : int32 -> int option Same as to_intunsigned integer. Returns None if the unsigned value of the argument cannot fit into an int.
val of_float : float -> int32Convert 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_intInt32.max_int
val to_float : int32 -> floatConvert the given 32-bit integer to a floating-point number.
val of_string : string -> int32Convert 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_intInt32.min_int + input - Int32.max_int - 1.
The _ (underscore) character can appear anywhere in the string and is ignored.
val of_string_opt : string -> int32 option Same as of_string, but return None instead of raising.
val to_string : int32 -> stringReturn the string representation of its argument, in signed decimal.
val bits_of_float : float -> int32Return 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.
val float_of_bits : int32 -> floatReturn the floating-point number whose internal representation, according to the IEEE 754 floating-point 'single format' bit layout, is the given int32.
An alias for the type of 32-bit integers.
val compare : t -> t -> The comparison function for 32-bit integers, with the same specification as Stdlib.comparet, this function compare allows the module Int32 to be passed as argument to the functors Set.MakeMap.Make
val unsigned_compare : t -> t -> Same as compareunsigned 32-bit integers.
val equal : t -> t -> The equal function for int32s.
Return the smaller of the two arguments.
Return the greater of the two arguments.
val seeded_hash : int -> t -> An unseeded hash function for 32-bit ints, with the same output value as Hashtbl.hashHashtbl.Make
Int64 (ocaml.Stdlib.Int64) Up – ocaml » Stdlib » Int64Module Stdlib.Int64 64-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 = -1Lval add : int64 -> int64 -> int64val sub : int64 -> int64 -> int64val mul : int64 -> int64 -> int64val div : int64 -> int64 -> int64val unsigned_div : int64 -> int64 -> int64Same as divunsigned 64-bit integers.
val rem : int64 -> int64 -> int64Integer 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.
val unsigned_rem : int64 -> int64 -> int64Same as remunsigned 64-bit integers.
val succ : int64 -> int64Successor. Int64.succ x is Int64.add x Int64.one.
val pred : int64 -> int64Predecessor. Int64.pred x is Int64.sub x Int64.one.
abs x is the absolute value of x. On min_int this is min_int itself and thus remains negative.
The greatest representable 64-bit integer, 263 - 1.
The smallest representable 64-bit integer, -263 .
val logand : int64 -> int64 -> int64val logor : int64 -> int64 -> int64val logxor : int64 -> int64 -> int64Bitwise logical exclusive or.
val lognot : int64 -> int64Bitwise logical negation.
val shift_left : int64 -> int -> int64Int64.shift_left x y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= 64.
val shift_right : int64 -> int -> int64Int64.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.
val shift_right_logical : int64 -> int -> int64Int64.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.
val of_int : int -> int64Convert the given integer (type int) to a 64-bit integer (type int64).
val to_int : int64 -> intConvert 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.
val unsigned_to_int : int64 -> int option Same as to_intunsigned integer. Returns None if the unsigned value of the argument cannot fit into an int.
val of_float : float -> int64Convert 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_intInt64.max_int
val to_float : int64 -> floatConvert the given 64-bit integer to a floating-point number.
val of_int32 : int32 -> int64Convert the given 32-bit integer (type int32) to a 64-bit integer (type int64).
val to_int32 : int64 -> int32Convert 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.
val of_nativeint : nativeint -> int64Convert the given native integer (type nativeint) to a 64-bit integer (type int64).
val to_nativeint : int64 -> nativeintConvert 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.
val of_string : string -> int64Convert 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_intInt64.min_int + input - Int64.max_int - 1.
The _ (underscore) character can appear anywhere in the string and is ignored.
val of_string_opt : string -> int64 option Same as of_string, but return None instead of raising.
val to_string : int64 -> stringReturn the string representation of its argument, in decimal.
val bits_of_float : float -> int64Return 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.
val float_of_bits : int64 -> floatReturn the floating-point number whose internal representation, according to the IEEE 754 floating-point 'double format' bit layout, is the given int64.
An alias for the type of 64-bit integers.
val compare : t -> t -> The comparison function for 64-bit integers, with the same specification as Stdlib.comparet, this function compare allows the module Int64 to be passed as argument to the functors Set.MakeMap.Make
val unsigned_compare : t -> t -> Same as compareunsigned 64-bit integers.
val equal : t -> t -> The equal function for int64s.
Return the smaller of the two arguments.
Return the greater of the two arguments.
val seeded_hash : int -> t -> An unseeded hash function for 64-bit ints, with the same output value as Hashtbl.hashHashtbl.Make
LargeFile (ocaml.Stdlib.LargeFile) Up – ocaml » Stdlib » LargeFileModule Stdlib.LargeFile Operations 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.
Lazy (ocaml.Stdlib.Lazy) Up – ocaml » Stdlib » LazyModule Stdlib.Lazy Deferred computations.
A 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 concurrency-safe. If you use this module with multiple fibers, systhreads or domains, then you will need to add some locks. The module however ensures memory-safety, and hence, concurrently accessing this module will not lead to a crash but the behaviour is unspecified.
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.
Raised when forcing a suspension concurrently from multiple fibers, systhreads or domains, or when the suspension tries to force itself recursively.
force 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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 -> is_val x returns true if x has already been forced and did not raise an exception.
val from_val : 'a -> 'a t from_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.
val map_val : ('a -> 'b ) -> 'a t -> 'b t 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 t from_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 -> 'a force_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
Lexing (ocaml.Stdlib.Lexing) Up – ocaml » Stdlib » Lexingtype position = { pos_fname : string; pos_lnum : int; pos_bol : int; pos_cnum : int; } 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.
A value of type position, guaranteed to be different from any valid position.
type lexbuf = { refill_buff : lexbuf -> 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).
Create 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 -> lexbuf Create 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) -> lexbuf Create 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
val set_filename : lexbuf -> string -> unitSet filename in the initial tracked position to file in lexbuf.
val with_positions : lexbuf -> Tell 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.
Lexing.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 -> Lexing.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 -> Lexing.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.
Update 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.
Discard the contents of the buffer and reset the current position to 0. The next use of the lexbuf will trigger a refill.
List (ocaml.Stdlib.List) Up – ocaml » Stdlib » ListModule Stdlib.List List 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
type 'a t = 'a list = | [] | :: of 'a * 'a listAn alias for the type of lists.
val length : 'a list-> Return the length (number of elements) of the given list.
val compare_lengths : 'a list-> 'b list-> 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.
val compare_length_with : 'a list-> int -> intCompare 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.
val is_empty : 'a list-> is_empty l is true if and only if l has no elements. It is equivalent to compare_length_with l 0 = 0.
val cons : 'a -> 'a list-> 'a listReturn the first element of the given list.
val tl : 'a list-> 'a listReturn the given list without its first element.
val nth : 'a list-> int -> 'a Return the n-th element of the given list. The first element (head of the list) is at position 0.
val nth_opt : 'a list-> int -> 'a optionReturn 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.
val rev : 'a list-> 'a listval init : int -> (int -> 'a ) -> 'a listinit len f is [f 0; f 1; ...; f (len-1)], evaluated left to right.
val append : 'a list-> 'a list-> 'a listappend l0 l1 appends l1 to l0. Same function as the infix operator @.
val rev_append : 'a list-> 'a list-> 'a listrev_append l1 l2 reverses l1 and concatenates it with l2. This is equivalent to (rev l1) @ l2.
val concat : 'a list-> 'a listConcatenate 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).
val flatten : 'a list-> 'a listSame as concat
val equal : ('a -> 'a -> -> 'a list-> 'a 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
val compare : ('a -> 'a -> -> 'a list-> 'a list-> 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 l2the empty list [] is strictly smaller than non-empty lists Note: the cmp function will be called even if the lists have different lengths.
val iter : ('a -> -> 'a list-> iter f [a1; ...; an] applies function f in turn to [a1; ...; an]. It is equivalent to f a1; f a2; ...; f an.
val iteri : (int -> 'a -> -> 'a list-> Same as iter
val map : ('a -> 'b ) -> 'a list-> 'b listmap f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f.
val mapi : (int -> 'a -> 'b ) -> 'a list-> 'b listSame as map
val rev_map : ('a -> 'b ) -> 'a list-> 'b listrev_map f l gives the same result as rev (map f l), but is more efficient.
val filter_map : ('a -> 'b option -> 'a list-> 'b listfilter_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.
val concat_map : ('a -> 'b list -> 'a list-> 'b listconcat_map f l gives the same result as concat (map f l). Tail-recursive.
val fold_left_map :
+ ('acc -> 'a -> 'acc * 'b ) -> 'acc -> 'a list-> 'acc * 'b listfold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.
val fold_left : ('acc -> 'a -> 'acc ) -> 'acc -> 'a list-> 'acc fold_left f init [b1; ...; bn] is f (... (f (f init b1) b2) ...) bn.
val fold_right : ('a -> 'acc -> 'acc ) -> 'a list-> 'acc -> 'acc fold_right f [a1; ...; an] init is f a1 (f a2 (... (f an init) ...)). Not tail-recursive.
val iter2 : ('a -> 'b -> -> 'a list-> 'b list-> iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
val map2 : ('a -> 'b -> 'c ) -> 'a list-> 'b list-> 'c listmap2 f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].
val rev_map2 : ('a -> 'b -> 'c ) -> 'a list-> 'b list-> 'c listrev_map2 f l1 l2 gives the same result as rev (map2 f l1 l2), but is more efficient.
val fold_left2 :
+ ('acc -> 'a -> 'b -> 'acc ) -> 'acc -> 'a list-> 'b list-> 'acc fold_left2 f init [a1; ...; an] [b1; ...; bn] is f (... (f (f init a1 b1) a2 b2) ...) an bn.
val fold_right2 :
+ ('a -> 'b -> 'acc -> 'acc ) -> 'a list-> 'b list-> 'acc -> 'acc fold_right2 f [a1; ...; an] [b1; ...; bn] init is f a1 b1 (f a2 b2 (... (f an bn init) ...)).
val for_all : ('a -> -> 'a list-> 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.
val exists : ('a -> -> 'a list-> 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.
val for_all2 : ('a -> 'b -> -> 'a list-> 'b list-> Same as for_all
val exists2 : ('a -> 'b -> -> 'a list-> 'b list-> Same as exists
val mem : 'a -> 'a list-> mem a set is true if and only if a is equal to an element of set.
val memq : 'a -> 'a list-> Same as mem
val find : ('a -> -> 'a list-> 'a find f l returns the first element of the list l that satisfies the predicate f.
val find_opt : ('a -> -> 'a list-> 'a optionfind 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.
val find_index : ('a -> -> 'a list-> int option find_index f xs returns Some i, where i is the index of the first element of the list xs that satisfies f x, if there is such an element.
It returns None if there is no such element.
val find_map : ('a -> 'b option -> 'a list-> 'b optionfind_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.
val find_mapi : (int -> 'a -> 'b option -> 'a list-> 'b optionSame as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
val filter : ('a -> -> 'a list-> 'a listfilter 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.
val find_all : ('a -> -> 'a list-> 'a listfind_all is another name for filter
val filteri : (int -> 'a -> -> 'a list-> 'a listSame as filter
val partition : ('a -> -> 'a list-> 'a list'a listpartition 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:
if f x is Left y1, then y1 is in l1, and if f 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.
val assoc : 'a -> ('a * 'b ) list-> 'b 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.
val assoc_opt : 'a -> ('a * 'b ) list-> 'b optionassoc_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.
val assq : 'a -> ('a * 'b ) list-> 'b Same as assoc
val assq_opt : 'a -> ('a * 'b ) list-> 'b optionSame as assoc_opt
val mem_assoc : 'a -> ('a * 'b ) list-> Same as assoctrue if a binding exists, and false if no bindings exist for the given key.
val mem_assq : 'a -> ('a * 'b ) list-> Same as mem_assoc
val remove_assoc : 'a -> ('a * 'b ) list-> ('a * 'b ) listremove_assoc a l returns the list of pairs l without the first pair with key a, if any. Not tail-recursive.
val remove_assq : 'a -> ('a * 'b ) list-> ('a * 'b ) listSame as remove_assoc
val split : ('a * 'b ) list-> 'a list'b listTransform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]). Not tail-recursive.
val combine : 'a list-> 'b list-> ('a * 'b ) listTransform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
val sort : ('a -> 'a -> -> 'a list-> 'a listSort 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.comparesort
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
val stable_sort : ('a -> 'a -> -> 'a list-> 'a listSame as sort
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
val fast_sort : ('a -> 'a -> -> 'a list-> 'a listval sort_uniq : ('a -> 'a -> -> 'a list-> 'a listSame as sort
val merge : ('a -> 'a -> -> 'a list-> 'a list-> 'a listMerge 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.t val of_seq : 'a Seq.t -> 'a listCreate a list from a sequence.
ListLabels (ocaml.Stdlib.ListLabels) Up – ocaml » Stdlib » ListLabelsModule Stdlib.ListLabels List 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
type 'a t = 'a list = | [] | :: of 'a * 'a listAn alias for the type of lists.
val length : 'a list-> Return the length (number of elements) of the given list.
val compare_lengths : 'a list-> 'b list-> 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.
val compare_length_with : 'a list-> len :int -> 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.
val is_empty : 'a list-> is_empty l is true if and only if l has no elements. It is equivalent to compare_length_with l 0 = 0.
val cons : 'a -> 'a list-> 'a listReturn the first element of the given list.
val tl : 'a list-> 'a listReturn the given list without its first element.
val nth : 'a list-> int -> 'a Return the n-th element of the given list. The first element (head of the list) is at position 0.
val nth_opt : 'a list-> int -> 'a optionReturn 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.
val rev : 'a list-> 'a listval init : len :int -> f :(int -> 'a ) -> 'a listinit ~len ~f is [f 0; f 1; ...; f (len-1)], evaluated left to right.
val append : 'a list-> 'a list-> 'a listappend l0 l1 appends l1 to l0. Same function as the infix operator @.
val rev_append : 'a list-> 'a list-> 'a listrev_append l1 l2 reverses l1 and concatenates it with l2. This is equivalent to (rev l1) @ l2.
val concat : 'a list-> 'a listConcatenate 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).
val flatten : 'a list-> 'a listSame as concat
val equal : eq :('a -> 'a -> -> 'a list-> 'a 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
val compare : cmp :('a -> 'a -> -> 'a list-> 'a list-> 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 l2the empty list [] is strictly smaller than non-empty lists Note: the cmp function will be called even if the lists have different lengths.
val iter : f :('a -> -> 'a list-> iter ~f [a1; ...; an] applies function f in turn to [a1; ...; an]. It is equivalent to f a1; f a2; ...; f an.
val iteri : f :(int -> 'a -> -> 'a list-> Same as iter
val map : f :('a -> 'b ) -> 'a list-> 'b listmap ~f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f.
val mapi : f :(int -> 'a -> 'b ) -> 'a list-> 'b listSame as map
val rev_map : f :('a -> 'b ) -> 'a list-> 'b listrev_map ~f l gives the same result as rev (map f l), but is more efficient.
val filter_map : f :('a -> 'b option -> 'a list-> 'b listfilter_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.
val concat_map : f :('a -> 'b list -> 'a list-> 'b listconcat_map ~f l gives the same result as concat (map f l). Tail-recursive.
val fold_left_map :
+ f :('acc -> 'a -> 'acc * 'b ) -> init :'acc -> 'a list-> 'acc * 'b listfold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.
val fold_left : f :('acc -> 'a -> 'acc ) -> init :'acc -> 'a list-> 'acc fold_left ~f ~init [b1; ...; bn] is f (... (f (f init b1) b2) ...) bn.
val fold_right : f :('a -> 'acc -> 'acc ) -> 'a list-> init :'acc -> 'acc fold_right ~f [a1; ...; an] ~init is f a1 (f a2 (... (f an init) ...)). Not tail-recursive.
val iter2 : f :('a -> 'b -> -> 'a list-> 'b list-> iter2 ~f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
val map2 : f :('a -> 'b -> 'c ) -> 'a list-> 'b list-> 'c listmap2 ~f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].
val rev_map2 : f :('a -> 'b -> 'c ) -> 'a list-> 'b list-> 'c listrev_map2 ~f l1 l2 gives the same result as rev (map2 f l1 l2), but is more efficient.
val fold_left2 :
+ f :('acc -> 'a -> 'b -> 'acc ) -> init :'acc -> 'a list-> 'b list-> 'acc fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn] is f (... (f (f init a1 b1) a2 b2) ...) an bn.
val fold_right2 :
+ f :('a -> 'b -> 'acc -> 'acc ) -> 'a list-> 'b list-> init :'acc -> 'acc fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init is f a1 b1 (f a2 b2 (... (f an bn init) ...)).
val for_all : f :('a -> -> 'a list-> 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.
val exists : f :('a -> -> 'a list-> 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.
val for_all2 : f :('a -> 'b -> -> 'a list-> 'b list-> Same as for_all
val exists2 : f :('a -> 'b -> -> 'a list-> 'b list-> Same as exists
val mem : 'a -> set :'a list-> mem a ~set is true if and only if a is equal to an element of set.
val memq : 'a -> set :'a list-> Same as mem
val find : f :('a -> -> 'a list-> 'a find ~f l returns the first element of the list l that satisfies the predicate f.
val find_opt : f :('a -> -> 'a list-> 'a optionfind ~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.
val find_index : f :('a -> -> 'a list-> int option find_index ~f xs returns Some i, where i is the index of the first element of the list xs that satisfies f x, if there is such an element.
It returns None if there is no such element.
val find_map : f :('a -> 'b option -> 'a list-> 'b optionfind_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.
val find_mapi : f :(int -> 'a -> 'b option -> 'a list-> 'b optionSame as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
val filter : f :('a -> -> 'a list-> 'a listfilter ~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.
val find_all : f :('a -> -> 'a list-> 'a listfind_all is another name for filter
val filteri : f :(int -> 'a -> -> 'a list-> 'a listSame as filter
val partition : f :('a -> -> 'a list-> 'a list'a listpartition ~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:
if f x is Left y1, then y1 is in l1, and if f 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.
val assoc : 'a -> ('a * 'b ) list-> 'b 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.
val assoc_opt : 'a -> ('a * 'b ) list-> 'b optionassoc_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.
val assq : 'a -> ('a * 'b ) list-> 'b Same as assoc
val assq_opt : 'a -> ('a * 'b ) list-> 'b optionSame as assoc_opt
val mem_assoc : 'a -> map :('a * 'b ) list-> Same as assoctrue if a binding exists, and false if no bindings exist for the given key.
val mem_assq : 'a -> map :('a * 'b ) list-> Same as mem_assoc
val remove_assoc : 'a -> ('a * 'b ) list-> ('a * 'b ) listremove_assoc a l returns the list of pairs l without the first pair with key a, if any. Not tail-recursive.
val remove_assq : 'a -> ('a * 'b ) list-> ('a * 'b ) listSame as remove_assoc
val split : ('a * 'b ) list-> 'a list'b listTransform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]). Not tail-recursive.
val combine : 'a list-> 'b list-> ('a * 'b ) listTransform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
val sort : cmp :('a -> 'a -> -> 'a list-> 'a listSort 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.comparesort
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
val stable_sort : cmp :('a -> 'a -> -> 'a list-> 'a listSame as sort
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
val fast_sort : cmp :('a -> 'a -> -> 'a list-> 'a listval sort_uniq : cmp :('a -> 'a -> -> 'a list-> 'a listSame as sort
val merge : cmp :('a -> 'a -> -> 'a list-> 'a list-> 'a listMerge 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.t val of_seq : 'a Seq.t -> 'a listCreate a list from a sequence.
Ord (ocaml.Stdlib.Map.Make.Ord) Up – ocaml » Stdlib » Map » Make » OrdThe type of the map keys.
val compare : t -> t -> 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
Make (ocaml.Stdlib.Map.Make) Up – ocaml » Stdlib » Map » MakeThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Map (ocaml.Stdlib.Map) Up – ocaml » Stdlib » MapModule Stdlib.Map Association 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.
Input signature of the functor Make
module type S = sig ... end Output signature of the functor Make
Functor building an implementation of the map structure given a totally ordered type.
OrderedType (ocaml.Stdlib.Map.OrderedType) Up – ocaml » Stdlib » Map » OrderedTypeThe type of the map keys.
val compare : t -> t -> 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
S (ocaml.Stdlib.Map.S) Up – ocaml » Stdlib » Map » SThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Marshal (ocaml.Stdlib.Marshal) Up – ocaml » Stdlib » MarshalModule Stdlib.Marshal Marshaling 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.
type extern_flags = | No_sharing | Closures | Compat_32 Ensure 32-bit compatibility
The flags to the Marshal.to_* functions below.
Marshal.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.
Marshal.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
Same 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-> Marshal.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.
Marshal.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.
val from_bytes : bytes -> int -> 'a Marshal.from_bytes buff ofs unmarshals a structured value like Marshal.from_channelbuff, starting at position ofs. The byte sequence is not mutated.
val from_string : string -> int -> 'a 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_sizeMarshal.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_sizebuff ofs is the total size, in bytes, of the marshaled value. Both Marshal.data_sizeMarshal.total_sizeFailure 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_sizeMarshal.data_sizeMarshal.from_bytes
val data_size : bytes -> int -> intval total_size : bytes -> int -> intH (ocaml.Stdlib.MoreLabels.Hashtbl.Make.H) Up – ocaml » Stdlib » MoreLabels » Hashtbl » Make » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Make (ocaml.Stdlib.MoreLabels.Hashtbl.Make) Up – ocaml » Stdlib » MoreLabels » Hashtbl » MakeModule Hashtbl.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.
val add : 'a t -> key :key -> data :'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key :key -> data :'a -> val mem : 'a t -> key -> val iter : f :(key :key -> data :'a -> -> 'a t -> val filter_map_inplace : f :(key :key -> data :'a -> 'a option -> 'a t -> val fold : f :(key :key -> data :'a -> 'acc -> 'acc ) -> 'a t -> init :'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> H (ocaml.Stdlib.MoreLabels.Hashtbl.MakeSeeded.H) Up – ocaml » Stdlib » MoreLabels » Hashtbl » MakeSeeded » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
MakeSeeded (ocaml.Stdlib.MoreLabels.Hashtbl.MakeSeeded) Up – ocaml » Stdlib » MoreLabels » Hashtbl » MakeSeededModule Hashtbl.MakeSeeded Functor 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
val create : ?random :bool -> int -> 'a t val add : 'a t -> key :key -> data :'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key :key -> data :'a -> val mem : 'a t -> key -> val iter : f :(key :key -> data :'a -> -> 'a t -> val filter_map_inplace : f :(key :key -> data :'a -> 'a option -> 'a t -> val fold : f :(key :key -> data :'a -> 'acc -> 'acc ) -> 'a t -> init :'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> Hashtbl (ocaml.Stdlib.MoreLabels.Hashtbl) Up – ocaml » Stdlib » MoreLabels » HashtblModule MoreLabels.Hashtbl Hash tables and hash functions.
Hash tables are hashed association tables, with in-place modification. Because most operations on a hash table modify their input, they're more commonly used in imperative code. The lookup of the value associated with a key (see findfind_optMap
The functors MakeMakeSeeded
Warning a hash table is only as good as the hash function. A bad hash function will turn the table into a degenerate association list, with linear time lookup instead of constant time lookup.
The polymorphic thash(=).
See the examples section .
Unsynchronized accesses
Unsynchronized accesses to a hash table may lead to an invalid hash table state. Thus, concurrent accesses to a hash tables must be synchronized (for instance with a Mutex.t
The type of hash tables from type 'a to type 'b.
val create : ?random :bool -> int -> ('a , 'b ) t Hashtbl.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
A hash table that is created with ~random set to true uses the seeded hash function seeded_hash2^{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 folditer
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 randomizeR flag in the OCAMLRUNPARAM environment variable.
val clear : ('a , 'b ) t -> Empty 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 -> Empty a hash table and shrink the size of the bucket table to its initial size.
val copy : ('a , 'b ) t -> ('a , 'b ) t Return a copy of the given hashtable.
val add : ('a , 'b ) t -> key :'a -> data :'b -> Hashtbl.add tbl ~key ~data adds a binding of key to data in table tbl.
Warning : 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.)
If you desire the classic behavior of replacing elements, see replace
val find : ('a , 'b ) t -> 'a -> 'b Hashtbl.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 -> Hashtbl.mem tbl x checks if x is bound in tbl.
val remove : ('a , 'b ) t -> 'a -> Hashtbl.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 -> Hashtbl.replace tbl ~key ~data replaces the current binding of key in tbl by a binding of key to data. If key is unbound in tbl, a binding of key to data is added to tbl. This is functionally equivalent to remove tbl key followed by add tbl key data.
val iter : f :(key :'a -> data :'b -> -> ('a , 'b ) t -> Hashtbl.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 -> Hashtbl.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
val fold :
+ f :(key :'a -> data :'b -> 'acc -> 'acc ) -> ('a , 'b ) t -> init :'acc -> 'acc Hashtbl.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 -> Hashtbl.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.
val randomize : unit -> unitAfter a call to Hashtbl.randomize(), hash tables are created in randomized mode by default: create~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 createHashtbl.randomize() at initialization time before any domains are created.
Note that once Hashtbl.randomize() was called, there is no way to revert to the non-randomized default behavior of createHashtbl.create ~random:false.
val is_randomized : unit -> boolReturn true if the tables are currently created in randomized mode by default, false otherwise.
val rebuild : ?random :bool -> ('a , 'b ) t -> ('a , 'b ) t Return a copy of the given hashtable. Unlike copyrebuild 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
rebuildHashtblrebuildHashtbl
type statistics = Hashtbl.statistics = { num_bindings : int; Number of bindings present in the table. Same value as returned by length
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.
} Hashtbl.stats tbl returns statistics about the table tbl: number of buckets, size of the biggest bucket, distribution of buckets by size.
val to_seq : ('a , 'b ) t -> ('a * 'b ) Seq.t 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.
val to_seq_keys : ('a , _ ) t -> 'a Seq.t Same as Seq.map fst (to_seq m)
val to_seq_values : (_ , 'b ) t -> 'b Seq.t Same as Seq.map snd (to_seq m)
val add_seq : ('a , 'b ) t -> ('a * 'b ) Seq.t -> Add the given bindings to the table, using add
val replace_seq : ('a , 'b ) t -> ('a * 'b ) Seq.t -> Add the given bindings to the table, using replace
val of_seq : ('a * 'b ) Seq.t -> ('a , 'b ) t Build a table from the given bindings. The bindings are added in the same order they appear in the sequence, using replace_seq
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.
The input signature of the functor Make
module type S = sig ... end The output 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.
Functor 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.
val seeded_hash : int -> 'a -> A variant of hash
val hash_param : int -> int -> 'a -> 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, hashseeded_hashmeaningful = 10 and total = 100.
val seeded_hash_param : int -> int -> int -> 'a -> A variant of hash_paramHashtbl.seeded_hash_param meaningful total seed x.
(* 0...99 *)
+let seq = Seq.ints 0 |> Seq.take 100
+
+(* build from Seq.t *)
+# let tbl =
+ seq
+ |> Seq.map (fun x -> x, string_of_int x)
+ |> Hashtbl.of_seq
+val tbl : (int, string) Hashtbl.t = <abstr>
+
+# Hashtbl.length tbl
+- : int = 100
+
+# Hashtbl.find_opt tbl 32
+- : string option = Some "32"
+
+# Hashtbl.find_opt tbl 166
+- : string option = None
+
+# Hashtbl.replace tbl 166 "one six six"
+- : unit = ()
+
+# Hashtbl.find_opt tbl 166
+- : string option = Some "one six six"
+
+# Hashtbl.length tbl
+- : int = 101Given a sequence of elements (here, a Seq.t
Here we illustrate that principle using a sequence of (ascii) characters (type char). We use a custom Char_tbl specialized for char.
# module Char_tbl = Hashtbl.Make(struct
+ type t = char
+ let equal = Char.equal
+ let hash = Hashtbl.hash
+ end)
+
+(* count distinct occurrences of chars in [seq] *)
+# let count_chars (seq : char Seq.t) : _ list =
+ let counts = Char_tbl.create 16 in
+ Seq.iter
+ (fun c ->
+ let count_c =
+ Char_tbl.find_opt counts c
+ |> Option.value ~default:0
+ in
+ Char_tbl.replace counts c (count_c + 1))
+ seq;
+ (* turn into a list *)
+ Char_tbl.fold (fun c n l -> (c,n) :: l) counts []
+ |> List.sort (fun (c1,_)(c2,_) -> Char.compare c1 c2)
+val count_chars : Char_tbl.key Seq.t -> (Char.t * int) list = <fun>
+
+(* basic seq from a string *)
+# let seq = String.to_seq "hello world, and all the camels in it!"
+val seq : char Seq.t = <fun>
+
+# count_chars seq
+- : (Char.t * int) list =
+[(' ', 7); ('!', 1); (',', 1); ('a', 3); ('c', 1); ('d', 2); ('e', 3);
+ ('h', 2); ('i', 2); ('l', 6); ('m', 1); ('n', 2); ('o', 2); ('r', 1);
+ ('s', 1); ('t', 2); ('w', 1)]
+
+(* "abcabcabc..." *)
+# let seq2 =
+ Seq.cycle (String.to_seq "abc") |> Seq.take 31
+val seq2 : char Seq.t = <fun>
+
+# String.of_seq seq2
+- : String.t = "abcabcabcabcabcabcabcabcabcabca"
+
+# count_chars seq2
+- : (Char.t * int) list = [('a', 11); ('b', 10); ('c', 10)]HashedType (ocaml.Stdlib.MoreLabels.Hashtbl.HashedType) Up – ocaml » Stdlib » MoreLabels » Hashtbl » HashedTypeThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash S (ocaml.Stdlib.MoreLabels.Hashtbl.S) Up – ocaml » Stdlib » MoreLabels » Hashtbl » Sval add : 'a t -> key :key -> data :'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key :key -> data :'a -> val mem : 'a t -> key -> val iter : f :(key :key -> data :'a -> -> 'a t -> val filter_map_inplace : f :(key :key -> data :'a -> 'a option -> 'a t -> val fold : f :(key :key -> data :'a -> 'acc -> 'acc ) -> 'a t -> init :'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> SeededHashedType (ocaml.Stdlib.MoreLabels.Hashtbl.SeededHashedType) Up – ocaml » Stdlib » MoreLabels » Hashtbl » SeededHashedTypeThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
val seeded_hash : int -> t -> A seeded hashing function on keys. The first argument is the seed. It must be the case that if equal x y is true, then seeded_hash seed x = seeded_hash seed y for any value of seed. A suitable choice for seeded_hash is the function Hashtbl.seeded_hash
SeededS (ocaml.Stdlib.MoreLabels.Hashtbl.SeededS) Up – ocaml » Stdlib » MoreLabels » Hashtbl » SeededSval create : ?random :bool -> int -> 'a t val add : 'a t -> key :key -> data :'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key :key -> data :'a -> val mem : 'a t -> key -> val iter : f :(key :key -> data :'a -> -> 'a t -> val filter_map_inplace : f :(key :key -> data :'a -> 'a option -> 'a t -> val fold : f :(key :key -> data :'a -> 'acc -> 'acc ) -> 'a t -> init :'acc -> 'acc val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a ) Seq.t -> val replace_seq : 'a t -> (key * 'a ) Seq.t -> Ord (ocaml.Stdlib.MoreLabels.Map.Make.Ord) Up – ocaml » Stdlib » MoreLabels » Map » Make » OrdThe type of the map keys.
val compare : t -> t -> 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
Make (ocaml.Stdlib.MoreLabels.Map.Make) Up – ocaml » Stdlib » MoreLabels » Map » MakeThe type of the map keys.
The type of maps from type key to type 'a.
val add : key :key -> data :'a -> 'a t -> 'a t add ~key ~data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key :key -> data :'a -> 'a listt -> 'a listt add_to_list ~key ~data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key :key -> f :('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ f :(key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge ~f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : f :(key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union ~f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : f :(key -> -> 'a t -> key * 'a 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.
val find_first_opt : f :(key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : f :(key -> -> 'a t -> key * 'a 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.
val find_last_opt : f :(key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : f :(key :key -> data :'a -> -> 'a t -> 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.
val fold : f :(key :key -> data :'a -> 'acc -> 'acc ) -> 'a t -> init :'acc -> 'acc 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.
val map : f :('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : f :(key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : f :(key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : f :(key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : f :(key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : cmp :('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : cmp :('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : f :(key -> 'a -> -> 'a t -> for_all ~f m checks if all the bindings of the map satisfy the predicate f.
val exists : f :(key -> 'a -> -> 'a t -> exists ~f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Map (ocaml.Stdlib.MoreLabels.Map) Up – ocaml » Stdlib » MoreLabels » MapModule MoreLabels.Map Association 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.
Input signature of the functor Make
module type S = sig ... end Output signature of the functor Make
Functor building an implementation of the map structure given a totally ordered type.
OrderedType (ocaml.Stdlib.MoreLabels.Map.OrderedType) Up – ocaml » Stdlib » MoreLabels » Map » OrderedTypeThe type of the map keys.
val compare : t -> t -> 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
S (ocaml.Stdlib.MoreLabels.Map.S) Up – ocaml » Stdlib » MoreLabels » Map » SThe type of the map keys.
The type of maps from type key to type 'a.
val add : key :key -> data :'a -> 'a t -> 'a t add ~key ~data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key :key -> data :'a -> 'a listt -> 'a listt add_to_list ~key ~data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key :key -> f :('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ f :(key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge ~f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : f :(key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union ~f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : f :(key -> -> 'a t -> key * 'a 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.
val find_first_opt : f :(key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : f :(key -> -> 'a t -> key * 'a 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.
val find_last_opt : f :(key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : f :(key :key -> data :'a -> -> 'a t -> 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.
val fold : f :(key :key -> data :'a -> 'acc -> 'acc ) -> 'a t -> init :'acc -> 'acc 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.
val map : f :('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : f :(key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : f :(key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : f :(key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : f :(key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : cmp :('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : cmp :('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : f :(key -> 'a -> -> 'a t -> for_all ~f m checks if all the bindings of the map satisfy the predicate f.
val exists : f :(key -> 'a -> -> 'a t -> exists ~f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Ord (ocaml.Stdlib.MoreLabels.Set.Make.Ord) Up – ocaml » Stdlib » MoreLabels » Set » Make » OrdThe type of the set elements.
val compare : t -> t -> 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
Make (ocaml.Stdlib.MoreLabels.Set.Make) Up – ocaml » Stdlib » MoreLabels » Set » MakeThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : f :(elt -> -> t -> elt 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.
val find_first_opt : f :(elt -> -> t -> elt optionfind_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.
val find_last : f :(elt -> -> t -> elt 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.
val find_last_opt : f :(elt -> -> t -> elt optionfind_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 iter : f :(elt -> -> t -> 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.
val fold : f :(elt -> 'acc -> 'acc ) -> t -> init :'acc -> 'acc fold ~f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : f :(elt -> -> t -> t 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).
val filter_map : f :(elt -> elt option -> t -> t 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.
val partition : f :(elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : f :(elt -> -> t -> for_all ~f s checks if all elements of the set satisfy the predicate f.
val exists : f :(elt -> -> t -> exists ~f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Set (ocaml.Stdlib.MoreLabels.Set) Up – ocaml » Stdlib » MoreLabels » SetModule MoreLabels.Set Sets 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 Makecompare 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.
Input signature of the functor Make
module type S = sig ... end Output signature of the functor Make
Functor building an implementation of the set structure given a totally ordered type.
OrderedType (ocaml.Stdlib.MoreLabels.Set.OrderedType) Up – ocaml » Stdlib » MoreLabels » Set » OrderedTypeThe type of the set elements.
val compare : t -> t -> 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
S (ocaml.Stdlib.MoreLabels.Set.S) Up – ocaml » Stdlib » MoreLabels » Set » SThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : f :(elt -> -> t -> elt 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.
val find_first_opt : f :(elt -> -> t -> elt optionfind_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.
val find_last : f :(elt -> -> t -> elt 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.
val find_last_opt : f :(elt -> -> t -> elt optionfind_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 iter : f :(elt -> -> t -> 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.
val fold : f :(elt -> 'acc -> 'acc ) -> t -> init :'acc -> 'acc fold ~f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : f :(elt -> -> t -> t 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).
val filter_map : f :(elt -> elt option -> t -> t 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.
val partition : f :(elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : f :(elt -> -> t -> for_all ~f s checks if all elements of the set satisfy the predicate f.
val exists : f :(elt -> -> t -> exists ~f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
MoreLabels (ocaml.Stdlib.MoreLabels) Up – ocaml » Stdlib » MoreLabelsModule Stdlib.MoreLabels Extra labeled libraries.
This meta-module provides labelized versions of the HashtblMapSet
This module is intended to be used through open MoreLabels which replaces HashtblMapSet
For example:
open MoreLabels
+
+Hashtbl.iter ~f:(fun ~key ~data -> g key data) tableHash tables and hash functions.
Association tables over ordered types.
Mutex (ocaml.Stdlib.Mutex) Up – ocaml » Stdlib » MutexModule Stdlib.Mutex Locks 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 mLock 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.
Same as Mutex.lockfalse immediately in that case. If the mutex is unlocked, lock it and return true.
Unlock 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
val protect : t -> (unit -> 'a ) -> 'a protect mutex f runs f() in a critical section where mutex is locked (using lockmutex, whether f() returned a value or raised an exception.
The unlocking operation is guaranteed to always takes place, even in the event an asynchronous exception (e.g. Sys.Break
Nativeint (ocaml.Stdlib.Nativeint) Up – ocaml » Stdlib » NativeintModule Stdlib.Nativeint Processor-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 = -1nval minus_one : nativeintval neg : nativeint -> nativeintval add : nativeint -> nativeint -> nativeintval sub : nativeint -> nativeint -> nativeintval mul : nativeint -> nativeint -> nativeintval div : nativeint -> nativeint -> nativeintInteger division. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/)
val unsigned_div : nativeint -> nativeint -> nativeintSame as divunsigned native integers.
val rem : nativeint -> nativeint -> nativeintInteger 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.
val unsigned_rem : nativeint -> nativeint -> nativeintSame as remunsigned native integers.
val succ : nativeint -> nativeintSuccessor. Nativeint.succ x is Nativeint.add x Nativeint.one.
val pred : nativeint -> nativeintPredecessor. Nativeint.pred x is Nativeint.sub x Nativeint.one.
val abs : nativeint -> nativeintabs x is the absolute value of x. On min_int this is min_int itself and thus remains negative.
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.
val logand : nativeint -> nativeint -> nativeintval logor : nativeint -> nativeint -> nativeintval logxor : nativeint -> nativeint -> nativeintBitwise logical exclusive or.
val lognot : nativeint -> nativeintBitwise logical negation.
val shift_left : nativeint -> int -> nativeintNativeint.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.
val shift_right : nativeint -> int -> nativeintNativeint.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.
val shift_right_logical : nativeint -> int -> nativeintNativeint.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 -> nativeintConvert the given integer (type int) to a native integer (type nativeint).
val to_int : nativeint -> intConvert the given native integer (type nativeint) to an integer (type int). The high-order bit is lost during the conversion.
val unsigned_to_int : nativeint -> int option Same as to_intunsigned integer. Returns None if the unsigned value of the argument cannot fit into an int.
val of_float : float -> nativeintConvert 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_intNativeint.max_int
val to_float : nativeint -> floatConvert the given native integer to a floating-point number.
val of_int32 : int32 -> nativeintConvert the given 32-bit integer (type int32) to a native integer.
val to_int32 : nativeint -> int32Convert 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.
val of_string : string -> nativeintConvert 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_intInt64.min_int + input - Nativeint.max_int - 1.
val of_string_opt : string -> nativeint option Same as of_string, but return None instead of raising.
val to_string : nativeint -> stringReturn the string representation of its argument, in decimal.
An alias for the type of native integers.
val compare : t -> t -> The comparison function for native integers, with the same specification as Stdlib.comparet, this function compare allows the module Nativeint to be passed as argument to the functors Set.MakeMap.Make
val unsigned_compare : t -> t -> Same as compareunsigned native integers.
val equal : t -> t -> The equal function for native ints.
Return the smaller of the two arguments.
Return the greater of the two arguments.
val seeded_hash : int -> t -> An unseeded hash function for native ints, with the same output value as Hashtbl.hashHashtbl.Make
Closure (ocaml.Stdlib.Obj.Closure) Up – ocaml » Stdlib » Obj » Closuretype info = { arity : int; start_env : int; } Ephemeron (ocaml.Stdlib.Obj.Ephemeron) Up – ocaml » Stdlib » Obj » Ephemeroncreate 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
return the number of keys
val get_key : t -> int -> obj_t optionval get_key_copy : t -> int -> obj_t optionval set_key : t -> int -> obj_t -> val unset_key : t -> int -> unitval check_key : t -> int -> boolval blit_key : t -> int -> t -> int -> int -> unitval get_data : t -> obj_t optionval get_data_copy : t -> obj_t optionval set_data : t -> obj_t -> val unset_data : t -> val check_data : t -> val blit_data : t -> t -> val max_ephe_length : intMaximum length of an ephemeron, ie the maximum number of keys an ephemeron could contain
Extension_constructor (ocaml.Stdlib.Obj.Extension_constructor) Up – ocaml » Stdlib » Obj » Extension_constructorModule Obj.Extension_constructor type t = extension_constructor Obj (ocaml.Stdlib.Obj) Up – ocaml » Stdlib » Objtype raw_data = nativeint val reachable_words : t -> Computes the total size (in words, including the headers) of all heap blocks accessible from the argument. Statically allocated blocks are included.
val field : t -> int -> t val set_field : t -> int -> t -> 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.
For experts only: set_field et al can be made safe by first wrapping the block in Sys.opaque_identity
val double_field : t -> int -> floatval set_double_field : t -> int -> float -> unitval set_raw_field : t -> int -> raw_data -> val new_block : int -> int -> t val with_tag : int -> t -> t val first_non_constant_constructor_tag : intval last_non_constant_constructor_tag : intval double_array_tag : intval out_of_heap_tag : intEphemeron with arbitrary arity and untyped
Oo (ocaml.Stdlib.Oo) Up – ocaml » Stdlib » OoModule Stdlib.Oo Operations on objects
val copy : < .. > as 'a -> 'a 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.
Option (ocaml.Stdlib.Option) Up – ocaml » Stdlib » Optiontype 'a t = 'a option = | None | Some of 'a The type for option values. Either None or a value Some v.
val some : 'a -> 'a optionval value : 'a option-> default :'a -> 'a value o ~default is v if o is Some v and default otherwise.
val get : 'a option-> 'a get o is v if o is Some v and raise otherwise.
val bind : 'a option-> ('a -> 'b option -> 'b optionbind o f is f v if o is Some v and None if o is None.
val join : 'a option-> 'a optionjoin oo is Some v if oo is Some (Some v) and None otherwise.
val map : ('a -> 'b ) -> 'a option-> 'b optionmap f o is None if o is None and Some (f v) if o is Some v.
val fold : none :'a -> some :('b -> 'a ) -> 'b option-> 'a fold ~none ~some o is none if o is None and some v if o is Some v.
val iter : ('a -> -> 'a option-> iter f o is f v if o is Some v and () otherwise.
val is_none : 'a option-> is_none o is true if and only if o is None.
val is_some : 'a option-> is_some o is true if and only if o is Some o.
val equal : ('a -> 'a -> -> 'a option-> 'a option-> 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.
val compare : ('a -> 'a -> -> 'a option-> 'a option-> 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 ) result to_result ~none o is Ok v if o is Some v and Error none otherwise.
val to_list : 'a option-> 'a listto_list o is [] if o is None and [v] if o is Some v.
val to_seq : 'a option-> 'a Seq.t to_seq o is o as a sequence. None is the empty sequence and Some v is the singleton sequence containing v.
Out_channel (ocaml.Stdlib.Out_channel) Up – ocaml » Stdlib » Out_channelThe type of output channel.
type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append open for appending: always write at end of file.
| Open_creat create the file if it does not exist.
| Open_trunc empty the file if it already exists.
| Open_excl fail if Open_creat and the file already exists.
| Open_binary open in binary mode (no conversion).
| Open_text open in text mode (may perform conversions).
| Open_nonblock open in non-blocking mode.
The standard output for the process.
The standard error output for the process.
val open_bin : string -> t Open 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 -> t Same as open_binopen_bin
val open_gen : open_flag list-> int -> string -> t open_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. open_textopen_bin
val with_open_bin : string -> (t -> 'a ) -> 'a with_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 ) -> 'a val with_open_gen : open_flag list-> int -> string -> (t -> 'a ) -> 'a Like with_open_binopen_gen
Close 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 closeflushcloseSys_error if the operating system signals an error when flushing or closing.
val close_noerr : t -> Same as close
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
Flush 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 flush_all : unit -> unitFlush all open output channels; ignore errors.
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.
Return 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 posseek
Return 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 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 flushflush_all
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 -> is_buffered oc returns whether the channel oc is buffered (see set_buffered
isatty oc is true if oc refers to a terminal or console window, false otherwise.
Writing the contents of a file:
let write_file file s =
+ Out_channel.with_open_bin file
+ (fun oc -> Out_channel.output_string oc s))Parsing (ocaml.Stdlib.Parsing) Up – ocaml » Stdlib » Parsingval symbol_start : unit -> intsymbol_start and Parsing.symbol_endsymbol_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.
val symbol_end : unit -> intval rhs_start : int -> intSame as Parsing.symbol_startParsing.symbol_endnth 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.
Same as symbol_start, but return a position instead of an offset.
Same as symbol_end, but return a position instead of an offset.
Same as rhs_start, but return a position instead of an offset.
Same as rhs_end, but return a position instead of an offset.
val clear_parser : unit -> unitEmpty 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.
val set_trace : bool -> boolControl 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.
Slot (ocaml.Stdlib.Printexc.Slot) Up – ocaml » Stdlib » Printexc » Slotis_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 -> is_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:
the slot corresponds to a compiler-inserted raise the slot corresponds to a part of the program that has not been compiled with debug information (-g) val name : t -> string option name 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.
format 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.
Printexc (ocaml.Stdlib.Printexc) Up – ocaml » Stdlib » PrintexcThe type of exception values.
val to_string : exn -> stringPrintexc.to_string e returns a string representation of the exception e.
val to_string_default : exn -> stringPrintexc.to_string_default e returns a string representation of the exception e, ignoring all registered exception printers.
val print : ('a -> 'b ) -> 'a -> 'b 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.
val catch : ('a -> 'b ) -> 'a -> 'b Printexc.catch fn x is similar to Printexc.printPrintexc.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.
Printexc.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.
val get_backtrace : unit -> stringPrintexc.get_backtrace () returns a string containing the same exception backtrace that Printexc.print_backtrace would print. Same restriction usage than print_backtrace
val record_backtrace : bool -> unitPrintexc.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.
val backtrace_status : unit -> boolPrintexc.backtrace_status() returns true if exception backtraces are currently recorded, false if not.
val register_printer : (exn -> string option ) -> 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.
val use_printers : exn -> string option 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.
type raw_backtrace_entry = private int 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.
Printexc.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
Print a raw backtrace in the same format Printexc.print_backtrace uses.
Return a string from a raw backtrace, in the same format Printexc.get_backtrace uses.
Reraise the exception using the given raw_backtrace for the origin of the exception
Printexc.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 -> Printexc.default_uncaught_exception_handler prints the exception and backtrace on standard error output.
val set_uncaught_exception_handler : (exn -> raw_backtrace -> -> Printexc.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_exitfn 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.
The abstract type backtrace_slot represents a single slot of a backtrace.
Returns 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:
none of the slots in the trace come from modules compiled with debug information (-g) the program is a bytecode program that has not been linked with debug information enabled (ocamlc -g) val backtrace_slots_of_raw_entry :
+ raw_backtrace_entry -> backtrace_slot arrayReturns 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.
type location = { filename : string; line_number : int; start_char : int; end_char : int; } 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 ... end This 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).
raw_backtrace_length bckt returns the number of slots in the backtrace bckt.
get_raw_backtrace_slot bckt pos returns the slot in position pos in the backtrace bckt.
Extracts the user-friendly backtrace_slot from a low-level raw_backtrace_slot.
get_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)
+ doneval exn_slot_id : exn -> intPrintexc.exn_slot_id returns an integer which uniquely identifies the constructor used to create the exception value exn (in the current runtime).
val exn_slot_name : exn -> stringPrintexc.exn_slot_name exn returns the internal name of the constructor used to create the exception value exn.
Printf (ocaml.Stdlib.Printf) Up – ocaml » Stdlib » Printffprintf 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.space: for signed numerical conversions, prefix number with a space 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 sprintf : ('a , unit, string) format -> 'a Same as Printf.fprintf
Same as Printf.fprintfBuffer
val ifprintf : 'b -> ('a , 'b , 'c , unit) format4 -> 'a Same as Printf.fprintf
Same as Printf.bprintf
Formatted output functions with continuations.
Same 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 -> 'a Same 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 -> 'a Same 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 -> 'a A deprecated synonym for ksprintf.
Queue (ocaml.Stdlib.Queue) Up – ocaml » Stdlib » QueueModule Stdlib.Queue First-in first-out queues.
This module implements queues (FIFOs), with in-place modification. See the example section below.
Unsynchronized accesses
Unsynchronized accesses to a queue may lead to an invalid queue state. Thus, concurrent accesses to queues must be synchronized (for instance with a Mutex.t
The type of queues containing elements of type 'a.
val create : unit -> 'a t Return a new queue, initially empty.
val add : 'a -> 'a t -> add x q adds the element x at the end of the queue q.
val push : 'a -> 'a t -> push is a synonym for add.
take q removes and returns the first element in queue q, or raises 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.
pop is a synonym for take.
peek q returns the first element in queue q, without removing it from the queue, or raises 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.
top is a synonym for peek.
Discard all elements from a queue.
Return a copy of the given queue.
val is_empty : 'a t -> Return true if the given queue is empty, false otherwise.
Return the number of elements in a queue.
val iter : ('a -> -> 'a t -> iter 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 : ('acc -> 'a -> 'acc ) -> 'acc -> 'a t -> 'acc fold 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.
val transfer : 'a t -> 'a t -> 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.
val add_seq : 'a t -> 'a Seq.t -> Add the elements from a sequence to the end of the queue.
Create a queue from a sequence.
A basic example:
# let q = Queue.create ()
+val q : '_weak1 Queue.t = <abstr>
+
+
+# Queue.push 1 q; Queue.push 2 q; Queue.push 3 q
+- : unit = ()
+
+# Queue.length q
+- : int = 3
+
+# Queue.pop q
+- : int = 1
+
+# Queue.pop q
+- : int = 2
+
+# Queue.pop q
+- : int = 3
+
+# Queue.pop q
+Exception: Stdlib.Queue.Empty.For a more elaborate example, a classic algorithmic use of queues is to implement a BFS (breadth-first search) through a graph.
type graph = {
+ edges: (int, int list) Hashtbl.t
+ }
+
+(* Search in graph [g] using BFS, starting from node [start].
+ It returns the first node that satisfies [p], or [None] if
+ no node reachable from [start] satisfies [p].
+*)
+let search_for ~(g:graph) ~(start:int) (p:int -> bool) : int option =
+ let to_explore = Queue.create() in
+ let explored = Hashtbl.create 16 in
+
+ Queue.push start to_explore;
+ let rec loop () =
+ if Queue.is_empty to_explore then None
+ else
+ (* node to explore *)
+ let node = Queue.pop to_explore in
+ explore_node node
+
+ and explore_node node =
+ if not (Hashtbl.mem explored node) then (
+ if p node then Some node (* found *)
+ else (
+ Hashtbl.add explored node ();
+ let children =
+ Hashtbl.find_opt g.edges node
+ |> Option.value ~default:[]
+ in
+ List.iter (fun child -> Queue.push child to_explore) children;
+ loop()
+ )
+ ) else loop()
+ in
+ loop()
+
+(* a sample graph *)
+let my_graph: graph =
+ let edges =
+ List.to_seq [
+ 1, [2;3];
+ 2, [10; 11];
+ 3, [4;5];
+ 5, [100];
+ 11, [0; 20];
+ ]
+ |> Hashtbl.of_seq
+ in {edges}
+
+# search_for ~g:my_graph ~start:1 (fun x -> x = 30)
+- : int option = None
+
+# search_for ~g:my_graph ~start:1 (fun x -> x >= 15)
+- : int option = Some 20
+
+# search_for ~g:my_graph ~start:1 (fun x -> x >= 50)
+- : int option = Some 100State (ocaml.Stdlib.Random.State) Up – ocaml » Stdlib » Random » Stateval make : int array -> t Create a new state and initialize it with the given seed.
val make_self_init : unit -> t Create a new state and initialize it with a random seed chosen in a system-dependent way. The seed is obtained as described in Random.self_init
Return a copy of the given state.
val int : t -> int -> intval full_int : t -> int -> intval float : t -> float -> floatThese functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one.
Draw a fresh PRNG state from the given PRNG state. (The given PRNG state is modified.) The new PRNG is statistically independent from the given PRNG. Data can be drawn from both PRNGs, in any order, without risk of correlation. Both PRNGs can be split later, arbitrarily many times.
val to_binary_string : t -> Serializes the PRNG state into an immutable sequence of bytes. See of_binary_string
The string type is intended here for serialization only, the encoding is not human-readable and may not be printable.
Note that the serialization format may differ across OCaml versions.
val of_binary_string : string -> t Deserializes a byte sequence obtained by calling to_binary_stringto_binary_string
Random (ocaml.Stdlib.Random) Up – ocaml » Stdlib » RandomModule Stdlib.Random Pseudo-random number generators (PRNG).
With multiple domains, each domain has its own generator that evolves independently of the generators of other domains. When a domain is created, its generator is initialized by splitting the state of the generator associated with the parent domain.
In contrast, all threads within a domain share the same domain-local generator. Independent generators can be created with the Random.splitRandom.State
Initialize the domain-local generator, using the argument as a seed. The same seed will always yield the same sequence of numbers.
val full_init : int array -> val self_init : unit -> unitInitialize the domain-local 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, domain-local state).
Return 30 random bits in a nonnegative integer.
Random.int bound returns a random integer between 0 (inclusive) and bound (exclusive). bound must be greater than 0 and less than 230 .
val full_int : int -> intRandom.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.intStdlib.Invalid_argument
Random.int32 bound returns a random integer between 0 (inclusive) and bound (exclusive). bound must be greater than 0.
Random.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.
val float : float -> floatRandom.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.
Random.bool () returns true or false with probability 0.5 each.
The functions from module State
module State : sig ... end get_state() returns a fresh copy of the current state of the domain-local generator (which is used by the basic functions).
set_state s updates the current state of the domain-local generator (which is used by the basic functions) by copying the state s into it.
Draw a fresh PRNG state from the current state of the domain-local generator used by the default functions. (The state of the domain-local generator is modified.) See Random.State.split
Result (ocaml.Stdlib.Result) Up – ocaml » Stdlib » Resulttype ('a, 'e) t = ('a , 'e ) result = | Ok of 'a | Error of 'e The type for result values. Either a value Ok v or an error Error e.
val ok : 'a -> ('a , 'e ) result val error : 'e -> ('a , 'e ) result val value : ('a , 'e ) result -> default :'a -> 'a value r ~default is v if r is Ok v and default otherwise.
val get_ok : ('a , 'e ) result -> 'a get_ok r is v if r is Ok v and raise otherwise.
val get_error : ('a , 'e ) result -> 'e get_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 _.
val map_error : ('e -> 'f ) -> ('a , 'e ) result -> ('a , 'f ) result 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 -> 'c fold ~ok ~error r is ok v if r is Ok v and error e if r is Error e.
val iter : ('a -> -> ('a , 'e ) result -> iter f r is f v if r is Ok v and () otherwise.
val iter_error : ('e -> -> ('a , 'e ) result -> iter_error f r is f e if r is Error e and () otherwise.
val is_ok : ('a , 'e ) result -> is_ok r is true if and only if r is Ok _.
val is_error : ('a , 'e ) result -> is_error r is true if and only if r is Error _.
val equal :
+ ok :('a -> 'a -> -> error :('e -> 'e -> -> ('a , 'e ) result -> ('a , 'e ) result -> equal ~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 -> -> error :('e -> 'e -> -> ('a , 'e ) result -> ('a , 'e ) result -> compare ~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.
to_seq r is r as a sequence. Ok v is the singleton sequence containing v and Error _ is the empty sequence.
Scanning (ocaml.Stdlib.Scanf.Scanning) Up – ocaml » Stdlib » Scanf » ScanningThe notion of input channel for the ScanfStdlib.in_channelformatted input channel or equivalently a scanning buffer . The type Scanning.scanbufScanning.in_channel. Note that a Scanning.in_channel is not concurrency-safe: concurrent use may produce arbitrary values or exceptions.
The 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.
The standard input notion for the ScanfScanning.stdin is the Scanning.in_channelStdlib.stdin
Note: in the interactive system, when input is read from Stdlib.stdin'\n' as the last character of the format string).
A convenient alias to designate a file name.
Scanning.open_in fname returns a Scanning.in_channelfname.
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.
Scanning.open_in_bin fname returns a Scanning.in_channelfname.
Scanning.from_string s returns a Scanning.in_channel
Scanning.from_function f returns a Scanning.in_channel
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.
Scanning.from_channel ic returns a Scanning.in_channelStdlib.in_channelic argument. Reading starts at current reading position of ic.
Scanning.end_of_input ic tests the end-of-input condition of the given Scanning.in_channel
Scanning.beginning_of_input ic tests the beginning of input condition of the given Scanning.in_channel
Scanning.name_of_input ic returns the name of the character source for the given Scanning.in_channel
Scanf (ocaml.Stdlib.Scanf) Up – ocaml » Stdlib » ScanfThe module Scanfscanners .
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_channelbscanf.
Generally speaking, the formatted input functions have 3 arguments:
the first argument is a source of characters for the input, the second argument is a format string that specifies the values to read, the third argument is a receiver function that is applied to the values read. Hence, a typical call to the formatted input function Scanf.bscanfbscanf ic fmt f, where:
ic is a source of characters (typically a formatted input channel with type Scanning.in_channelfmt is a format string (the same format strings as those used to print material with module PrintfFormatf 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,
if we use stdin as the source of characters (Scanning.stdin if we define the receiver 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.
Unsynchronized accesses
Unsynchronized accesses to a Scanning.in_channelScanning.in_channelScanning.in_channelMutex.t
The 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_channelic.
For instance, the Scanf.scanf('a, 'b, 'c, 'd) scanner, since it is a formatted input function that reads from Scanning.stdinscanf fmt f applies f to the arguments specified by fmt, reading those arguments from Stdlib.stdin
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.
exception Scan_failure of stringWhen the input can not be read according to the format string specification, formatted input functions typically raise exception Scan_failure.
bscanf ic fmt r1 ... rN f reads characters from the Scanning.in_channelic 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.
Same as Scanf.bscanfNone in case of scanning failure.
The format string is a character string which contains three types of objects:
plain characters, which are simply matched with the characters of the input (with a special case for space and line feed, see space conversion specifications, each of which causes reading and conversion of one argument for the function f (see conversion scanning indications to specify boundaries of tokens (see scanning 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:
a whitespace has been found (see space a scanning indication (see scanning indication the end-of-input has been reached. 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:
as mentioned above, a %s conversion always succeeds, even if there is nothing to read in the input: in this case, it simply returns "". in addition to the relevant digits, '_' 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. the 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 Strocamllex-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:
As usual in format strings, % 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 @. The scanning indications introduce slight differences in the syntax of ScanfPrintfFormatScanf.bscanfFormatPrintf'@' characters). Scanners may raise the following exceptions when the input cannot be read according to the format string:
Raise Failure if a conversion to a number is not possible. Raise End_of_file if the end of input is encountered while some more characters are needed to read the current conversion specification. Raise Invalid_argument if the format string is invalid. Note:
as a consequence, scanning a %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 ) scanner val sscanf_opt : string -> ('a , 'b , 'c , 'd ) scanner_opt Same as Scanf.sscanfNone in case of scanning failure.
val scanf : ('a , 'b , 'c , 'd ) scanner Same as Scanf.scanfNone in case of scanning failure.
Same as Scanf.bscanfef 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.
bscanf_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.
format_from_string s fmt converts a string argument to a format string, according to the given format string fmt.
val unescaped : string -> stringunescaped 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.
Binary (ocaml.Stdlib.Semaphore.Binary) Up – ocaml » Stdlib » Semaphore » BinaryThe type of binary semaphores.
make 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".
release 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.
acquire 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 -> try_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.
Counting (ocaml.Stdlib.Semaphore.Counting) Up – ocaml » Stdlib » Semaphore » CountingModule Semaphore.Counting The type of counting semaphores.
make n returns a new counting semaphore, with initial value n. The initial value n must be nonnegative.
release 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.
acquire 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 -> try_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.
get_value s returns the current value of semaphore s. The current value can be modified at any time by concurrent releaseacquireget_value operation is racy, and its result should only be used for debugging or informational messages.
Semaphore (ocaml.Stdlib.Semaphore) Up – ocaml » Stdlib » SemaphoreModule Stdlib.Semaphore Semaphores
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:
"release" (also called "V", "post", "up", and "signal"), which increments the value of the counter. This corresponds to producing one more unit of the shared resource and making it available to others. "acquire" (also called "P", "wait", "down", and "pend"), which waits until the counter is greater than zero and decrements it. This corresponds to consuming one unit of the shared resource. Binary 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
Seq (ocaml.Stdlib.Seq) Up – ocaml » Stdlib » SeqModule Stdlib.Seq Sequences.
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:
persistent , which means that the sequence can be used as many times as desired, producing the same elements every time, just like an immutable list; orephemeral , which means that the sequence is not persistent. Querying an ephemeral sequence might have an observable side effect, such as incrementing a mutable counter. As a common special case, an ephemeral sequence can be affine , which means that it must be queried at most once.It also does not reveal whether the elements of the sequence are:
pre-computed and stored in memory, which means that querying the sequence is cheap;computed when first demanded and then stored in memory, which means that querying the sequence once can be expensive, but querying the same sequence again is cheap; orre-computed every time they are demanded , which may or may not be cheap.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_dispenserof_dispenser
type 'a t = unit -> 'a node A 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.
and +'a node = | Nil | Cons of 'a * 'a t 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 -> is_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.
val uncons : 'a t -> ('a * 'a t optionIf xs is empty, then uncons xs is None.
If xs is nonempty, then uncons xs is Some (x, ys) where x is the head of the sequence and ys its tail.
length xs is the length of the sequence xs.
The sequence xs must be finite.
val iter : ('a -> -> 'a t -> iter 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 : ('acc -> 'a -> 'acc ) -> 'acc -> 'a t -> 'acc fold_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 -> -> 'a t -> iteri 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 : ('acc -> int -> 'a -> 'acc ) -> 'acc -> 'a t -> 'acc fold_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 -> -> 'a t -> for_all p xs determines whether all elements x of the sequence xs satisfy p x.
The sequence xs must be finite.
val exists : ('a -> -> 'a t -> exists 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 -> -> '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_index : ('a -> -> 'a t -> int option find_index p xs returns Some i, where i is the index of 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.
val find_mapi : (int -> 'a -> 'b option -> 'a t -> 'b optionSame as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
The sequence xs must be finite.
val iter2 : ('a -> 'b -> -> 'a t -> 'b t -> 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).
val fold_left2 : ('acc -> 'a -> 'b -> 'acc ) -> 'acc -> 'a t -> 'b t -> 'acc 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).
val for_all2 : ('a -> 'b -> -> 'a t -> 'b t -> 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).
val exists2 : ('a -> 'b -> -> 'a t -> 'b t -> 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).
val equal : ('a -> 'b -> -> 'a t -> 'b t -> 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.
val compare : ('a -> 'b -> -> 'a t -> 'b t -> 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.
empty is the empty sequence. It has no elements. Its length is 0.
return x is the sequence whose sole element is x. Its length is 1.
val cons : 'a -> 'a t -> 'a t 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 t init 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 t unfold 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.
repeat 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 t forever 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 t iterate 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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; ....
val mapi : (int -> 'a -> 'b ) -> 'a t -> 'b t 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.
val filter : ('a -> -> 'a t -> 'a t 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.
val filter_map : ('a -> 'b option -> 'a t -> 'b t 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)).
val scan : ('b -> 'a -> 'b ) -> 'b -> 'a t -> 'b t 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.
val take : int -> 'a t -> 'a t 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.
val drop : int -> 'a t -> 'a t 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.
val take_while : ('a -> -> 'a t -> 'a t take_while p xs is the longest prefix of the sequence xs where every element x satisfies p x.
val drop_while : ('a -> -> 'a t -> 'a t drop_while p xs is the sequence xs, deprived of the prefix take_while p xs.
val group : ('a -> 'a -> -> 'a t -> 'a t t 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.
val memoize : 'a t -> 'a t 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 Lazynot 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
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.
val transpose : 'a t t -> 'a t t 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.
val append : 'a t -> 'a t -> 'a t 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.
val concat : 'a t t -> 'a t 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 @ ....
val flat_map : ('a -> 'b t -> 'a t -> 'b t flat_map f xs is equivalent to concat (map f xs).
val concat_map : ('a -> 'b t -> 'a t -> 'b t concat_map f xs is equivalent to concat (map f xs).
concat_map is an alias for flat_map.
val zip : 'a t -> 'b t -> ('a * 'b ) t 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.
val map2 : ('a -> 'b -> 'c ) -> 'a t -> 'b t -> 'c t 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).
val interleave : 'a t -> 'a t -> 'a t 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.
val sorted_merge : ('a -> 'a -> -> 'a t -> 'a t -> 'a t 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
val product : 'a t -> 'b t -> ('a * 'b ) t 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.
val map_product : ('a -> 'b -> 'c ) -> 'a t -> 'b t -> 'c t 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).
val unzip : ('a * 'b ) t -> 'a t 'b t 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).
val split : ('a * 'b ) t -> 'a t 'b t split is an alias for unzip.
val partition_map : ('a -> ('b , 'c ) Either.t -> 'a t -> 'b t 'c t 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).
val partition : ('a -> -> 'a t -> 'a t 'a t 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 t of_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.
ints i is the infinite sequence of the integers beginning at i and counting up.
Ord (ocaml.Stdlib.Set.Make.Ord) Up – ocaml » Stdlib » Set » Make » OrdThe type of the set elements.
val compare : t -> t -> 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
Make (ocaml.Stdlib.Set.Make) Up – ocaml » Stdlib » Set » MakeThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Set (ocaml.Stdlib.Set) Up – ocaml » Stdlib » SetModule Stdlib.Set Sets 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 Makecompare 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.
Input signature of the functor Make
module type S = sig ... end Output signature of the functor Make
Functor building an implementation of the set structure given a totally ordered type.
OrderedType (ocaml.Stdlib.Set.OrderedType) Up – ocaml » Stdlib » Set » OrderedTypeThe type of the set elements.
val compare : t -> t -> 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
S (ocaml.Stdlib.Set.S) Up – ocaml » Stdlib » Set » SThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Stack (ocaml.Stdlib.Stack) Up – ocaml » Stdlib » StackModule Stdlib.Stack Last-in first-out stacks.
This module implements stacks (LIFOs), with in-place modification.
Unsynchronized accesses
Unsynchronized accesses to a stack may lead to an invalid queue state. Thus, concurrent accesses to stacks must be synchronized (for instance with a Mutex.t
The type of stacks containing elements of type 'a.
val create : unit -> 'a t Return a new stack, initially empty.
val push : 'a -> 'a t -> push x s adds the element x at the top of stack s.
pop s removes and returns the topmost element in stack s, or raises 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.
drop s removes the topmost element in stack s, or raises Empty
top s returns the topmost element in stack s, or raises Empty
val top_opt : 'a t -> 'a optiontop_opt s returns the topmost element in stack s, or None if the stack is empty.
Discard all elements from a stack.
Return a copy of the given stack.
val is_empty : 'a t -> Return true if the given stack is empty, false otherwise.
Return the number of elements in a stack. Time complexity O(1)
val iter : ('a -> -> 'a t -> iter 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 : ('acc -> 'a -> 'acc ) -> 'acc -> 'a t -> 'acc fold 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.
val add_seq : 'a t -> 'a Seq.t -> Add the elements from the sequence on the top of the stack.
Create a stack from the sequence.
StdLabels (ocaml.Stdlib.StdLabels) Up – ocaml » Stdlib » StdLabelsModule Stdlib.StdLabels Standard labeled libraries.
This meta-module provides versions of the ArrayBytesListString
open StdLabels
+
+let to_upper = String.map ~f:Char.uppercase_ascii
+let seq len = List.init ~f:(fun i -> i) ~len
+let everything = Array.create_matrix ~dimx:42 ~dimy:42 42String (ocaml.Stdlib.String) Up – ocaml » Stdlib » StringModule Stdlib.String Strings.
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 |
+ +---+---+---+---+ +-----+ An index 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]. A position 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. Before OCaml 4.02, strings used to be modifiable in place like Bytes.t
The labeled version of this module can be used as described in the StdLabels
val make : int -> char -> stringmake n c is a string of length n with each index holding the character c.
val init : int -> (int -> char) -> init n f is a string of length n with index i holding the character f i (called in increasing index order).
val length : string -> intlength s is the length (number of bytes/characters) of s.
val get : string -> int -> charget s i is the character at index i in s. This is the same as writing s.[i].
val of_bytes : bytes -> stringReturn a new string that contains the same bytes as the given byte sequence.
val to_bytes : string -> bytesReturn a new byte sequence that contains the same bytes as the given string.
val blit : string -> int -> bytes -> int -> int -> unitNote. The Stdlib.(^)
val concat : string -> string list -> concat sep ss concatenates the list of strings ss, inserting the separator string sep between each.
val cat : string -> string -> stringcat s1 s2 concatenates s1 and s2 (s1 ^ s2).
val equal : t -> t -> equal s0 s1 is true if and only if s0 and s1 are character-wise equal.
val compare : t -> t -> compare s0 s1 sorts s0 and s1 in lexicographical order. compare behaves like Stdlib.compare
val starts_with : prefix :string -> string -> boolstarts_with ~prefix s is true if and only if s starts with prefix.
val ends_with : suffix :string -> string -> boolends_with ~suffix s is true if and only if s ends with suffix.
val contains_from : string -> int -> char -> boolcontains_from s start c is true if and only if c appears in s after position start.
val rcontains_from : string -> int -> char -> boolrcontains_from s stop c is true if and only if c appears in s before position stop+1.
val contains : string -> char -> boolval sub : string -> int -> int -> stringsub s pos len is a string of length len, containing the substring of s that starts at position pos and has length len.
val split_on_char : char -> string -> string list 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:
The list is not empty. Concatenating its elements using sep as a separator returns a string equal to the input (concat (make 1 sep)
+ (split_on_char sep s) = s). No string in the result contains the sep character. val map : (char -> char) -> string -> stringmap f s is the string resulting from applying f to all the characters of s in increasing order.
val mapi : (int -> char -> char) -> string -> stringmapi f s is like mapf.
val fold_left : ('acc -> char -> 'acc ) -> 'acc -> string -> 'acc 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.
val fold_right : (char -> 'acc -> 'acc ) -> string -> 'acc -> 'acc 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.
val for_all : (char -> bool) -> string -> boolfor_all p s checks if all characters in s satisfy the predicate p.
val exists : (char -> bool) -> string -> boolexists p s checks if at least one character of s satisfies the predicate p.
val trim : string -> stringtrim s is s without leading and trailing whitespace. Whitespace characters are: ' ', '\x0C' (form feed), '\n', '\r', and '\t'.
val escaped : string -> stringescaped 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.unescapedescaped, i.e. Scanf.unescaped (escaped s) = s for any string s (unless escaped s fails).
val uppercase_ascii : string -> stringuppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.
val lowercase_ascii : string -> stringlowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.
val capitalize_ascii : string -> stringcapitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.
val uncapitalize_ascii : string -> stringuncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.
val iter : (char -> unit) -> string -> unititer 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]; ().
val iteri : (int -> char -> unit) -> string -> unititeri is like iter
val index_from : string -> int -> char -> intindex_from s i c is the index of the first occurrence of c in s after position i.
val index_from_opt : string -> int -> char -> int option index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).
val rindex_from : string -> int -> char -> intrindex_from s i c is the index of the last occurrence of c in s before position i+1.
val rindex_from_opt : string -> int -> char -> int option rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).
val index : string -> char -> intval index_opt : string -> char -> int option val rindex : string -> char -> intval rindex_opt : string -> char -> int option 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.
val to_seqi : t -> (int * char) Seq.t to_seqi s is like to_seq
of_seq s is a string made of the sequence's characters.
get_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val is_valid_utf_8 : t -> is_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
get_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val is_valid_utf_16be : t -> is_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
get_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val is_valid_utf_16le : t -> is_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
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.
val get_uint8 : string -> int -> intget_uint8 b i is b's unsigned 8-bit integer starting at character index i.
val get_int8 : string -> int -> intget_int8 b i is b's signed 8-bit integer starting at character index i.
val get_uint16_ne : string -> int -> intget_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.
val get_uint16_be : string -> int -> intget_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.
val get_uint16_le : string -> int -> intget_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.
val get_int16_ne : string -> int -> intget_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.
val get_int16_be : string -> int -> intget_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.
val get_int16_le : string -> int -> intget_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.
val get_int32_ne : string -> int -> int32get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.
An unseeded hash function for strings, with the same output value as Hashtbl.hashHashtbl.Make
val seeded_hash : int -> t -> val get_int32_be : string -> int -> int32get_int32_be b i is b's big-endian 32-bit integer starting at character index i.
val get_int32_le : string -> int -> int32get_int32_le b i is b's little-endian 32-bit integer starting at character index i.
val get_int64_ne : string -> int -> int64get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.
val get_int64_be : string -> int -> int64get_int64_be b i is b's big-endian 64-bit integer starting at character index i.
val get_int64_le : string -> int -> int64get_int64_le b i is b's little-endian 64-bit integer starting at character index i.
StringLabels (ocaml.Stdlib.StringLabels) Up – ocaml » Stdlib » StringLabelsModule Stdlib.StringLabels Strings.
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 |
+ +---+---+---+---+ +-----+ An index 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]. A position 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. Before OCaml 4.02, strings used to be modifiable in place like Bytes.t
The labeled version of this module can be used as described in the StdLabels
val make : int -> char -> stringmake n c is a string of length n with each index holding the character c.
val init : int -> f :(int -> char) -> init n ~f is a string of length n with index i holding the character f i (called in increasing index order).
val length : string -> intlength s is the length (number of bytes/characters) of s.
val get : string -> int -> charget s i is the character at index i in s. This is the same as writing s.[i].
val of_bytes : bytes -> stringReturn a new string that contains the same bytes as the given byte sequence.
val to_bytes : string -> bytesReturn a new byte sequence that contains the same bytes as the given string.
val blit :
+ src :string -> src_pos :int -> dst :bytes -> dst_pos :int -> len :int -> Note. The Stdlib.(^)
val concat : sep :string -> string list -> concat ~sep ss concatenates the list of strings ss, inserting the separator string sep between each.
val cat : string -> string -> stringcat s1 s2 concatenates s1 and s2 (s1 ^ s2).
val equal : t -> t -> equal s0 s1 is true if and only if s0 and s1 are character-wise equal.
val compare : t -> t -> compare s0 s1 sorts s0 and s1 in lexicographical order. compare behaves like Stdlib.compare
val starts_with : prefix :string -> string -> boolstarts_with ~prefix s is true if and only if s starts with prefix.
val ends_with : suffix :string -> string -> boolends_with ~suffix s is true if and only if s ends with suffix.
val contains_from : string -> int -> char -> boolcontains_from s start c is true if and only if c appears in s after position start.
val rcontains_from : string -> int -> char -> boolrcontains_from s stop c is true if and only if c appears in s before position stop+1.
val contains : string -> char -> boolval sub : string -> pos :int -> len :int -> sub s ~pos ~len is a string of length len, containing the substring of s that starts at position pos and has length len.
val split_on_char : sep :char -> string -> string list 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:
The list is not empty. Concatenating its elements using sep as a separator returns a string equal to the input (concat (make 1 sep)
+ (split_on_char sep s) = s). No string in the result contains the sep character. val map : f :(char -> char) -> string -> stringmap f s is the string resulting from applying f to all the characters of s in increasing order.
val mapi : f :(int -> char -> char) -> string -> stringmapi ~f s is like mapf.
val fold_left : f :('acc -> char -> 'acc ) -> init :'acc -> string -> 'acc 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.
val fold_right : f :(char -> 'acc -> 'acc ) -> string -> init :'acc -> 'acc 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.
val for_all : f :(char -> bool) -> string -> boolfor_all p s checks if all characters in s satisfy the predicate p.
val exists : f :(char -> bool) -> string -> boolexists p s checks if at least one character of s satisfies the predicate p.
val trim : string -> stringtrim s is s without leading and trailing whitespace. Whitespace characters are: ' ', '\x0C' (form feed), '\n', '\r', and '\t'.
val escaped : string -> stringescaped 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.unescapedescaped, i.e. Scanf.unescaped (escaped s) = s for any string s (unless escaped s fails).
val uppercase_ascii : string -> stringuppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.
val lowercase_ascii : string -> stringlowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.
val capitalize_ascii : string -> stringcapitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.
val uncapitalize_ascii : string -> stringuncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.
val iter : f :(char -> unit) -> string -> unititer ~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]; ().
val iteri : f :(int -> char -> unit) -> string -> unititeri is like iter
val index_from : string -> int -> char -> intindex_from s i c is the index of the first occurrence of c in s after position i.
val index_from_opt : string -> int -> char -> int option index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).
val rindex_from : string -> int -> char -> intrindex_from s i c is the index of the last occurrence of c in s before position i+1.
val rindex_from_opt : string -> int -> char -> int option rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).
val index : string -> char -> intval index_opt : string -> char -> int option val rindex : string -> char -> intval rindex_opt : string -> char -> int option 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.
val to_seqi : t -> (int * char) Seq.t to_seqi s is like to_seq
of_seq s is a string made of the sequence's characters.
get_utf_8_uchar b i decodes an UTF-8 character at index i in b.
val is_valid_utf_8 : t -> is_valid_utf_8 b is true if and only if b contains valid UTF-8 data.
get_utf_16be_uchar b i decodes an UTF-16BE character at index i in b.
val is_valid_utf_16be : t -> is_valid_utf_16be b is true if and only if b contains valid UTF-16BE data.
get_utf_16le_uchar b i decodes an UTF-16LE character at index i in b.
val is_valid_utf_16le : t -> is_valid_utf_16le b is true if and only if b contains valid UTF-16LE data.
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.
val get_uint8 : string -> int -> intget_uint8 b i is b's unsigned 8-bit integer starting at character index i.
val get_int8 : string -> int -> intget_int8 b i is b's signed 8-bit integer starting at character index i.
val get_uint16_ne : string -> int -> intget_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.
val get_uint16_be : string -> int -> intget_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.
val get_uint16_le : string -> int -> intget_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.
val get_int16_ne : string -> int -> intget_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.
val get_int16_be : string -> int -> intget_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.
val get_int16_le : string -> int -> intget_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.
val get_int32_ne : string -> int -> int32get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.
An unseeded hash function for strings, with the same output value as Hashtbl.hashHashtbl.Make
val seeded_hash : int -> t -> val get_int32_be : string -> int -> int32get_int32_be b i is b's big-endian 32-bit integer starting at character index i.
val get_int32_le : string -> int -> int32get_int32_le b i is b's little-endian 32-bit integer starting at character index i.
val get_int64_ne : string -> int -> int64get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.
val get_int64_be : string -> int -> int64get_int64_be b i is b's big-endian 64-bit integer starting at character index i.
val get_int64_le : string -> int -> int64get_int64_le b i is b's little-endian 64-bit integer starting at character index i.
Immediate (ocaml.Stdlib.Sys.Immediate64.Make.Immediate) Up – ocaml » Stdlib » Sys » Immediate64 » Make » ImmediateNon_immediate (ocaml.Stdlib.Sys.Immediate64.Make.Non_immediate) Up – ocaml » Stdlib » Sys » Immediate64 » Make » Non_immediateParameter Make.Non_immediate Make (ocaml.Stdlib.Sys.Immediate64.Make) Up – ocaml » Stdlib » Sys » Immediate64 » MakeImmediate64 (ocaml.Stdlib.Sys.Immediate64) Up – ocaml » Stdlib » Sys » Immediate64Module Sys.Immediate64 This 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.
Immediate (ocaml.Stdlib.Sys.Immediate64.Immediate) Up – ocaml » Stdlib » Sys » Immediate64 » ImmediateModule type Immediate64.Immediate Non_immediate (ocaml.Stdlib.Sys.Immediate64.Non_immediate) Up – ocaml » Stdlib » Sys » Immediate64 » Non_immediateModule type Immediate64.Non_immediate Sys (ocaml.Stdlib.Sys) Up – ocaml » Stdlib » SysThe 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.
val executable_name : stringThe 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.
val file_exists : string -> boolTest if a file with the given name exists.
val is_directory : string -> boolReturns true if the given name refers to a directory, false if it refers to another kind of file.
val is_regular_file : string -> boolReturns true if the given name refers to a regular file, false if it refers to another kind of file.
val remove : string -> unitRemove the given file name from the file system.
val rename : string -> string -> unitRename a file or directory. rename oldpath newpath renames the file or directory called oldpath, giving it newpath as its new name, moving it between (parent) directories if needed. If a file named 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.
val getenv : string -> stringReturn the value associated to a variable in the process environment.
val getenv_opt : string -> string option Return the value associated to a variable in the process environment or None if the variable is unbound.
val command : string -> intExecute the given shell command and return its exit code.
The argument of Sys.commandcmd.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
Return the processor time, in seconds, used by the program since the beginning of execution.
val chdir : string -> unitChange the current working directory of the process.
val mkdir : string -> int -> unitCreate a directory with the given permissions.
val rmdir : string -> unitRemove an empty directory.
val getcwd : unit -> stringReturn the current working directory of the process.
val readdir : string -> string array 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 ref This 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-w64),"Cygwin" (for MS-Windows, OCaml compiled with Cygwin).type backend_type = | Native | Bytecode | Other of stringCurrently, the official distribution only supports Native and Bytecode, but it can be other backends with alternative compilers, for example, javascript.
Backend type currently executing the OCaml program.
True if Sys.os_type = "Unix".
True if Sys.os_type = "Win32".
True if Sys.os_type = "Cygwin".
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.
Whether the machine currently executing the Caml program is big-endian.
val max_string_length : intMaximum length of strings and byte sequences.
val max_array_length : intMaximum 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.
val max_floatarray_length : intMaximum length of a floatarray. This is also the maximum length of a float array when OCaml is configured with --enable-flat-float-array.
val runtime_variant : unit -> stringReturn 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.
val runtime_parameters : unit -> stringReturn the value of the runtime parameters, in the same format as the contents of the OCAMLRUNPARAM environment variable.
type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of int -> unitWhat 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.Set 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.
Hangup on controlling terminal
Invalid hardware instruction
Interactive interrupt (ctrl-C)
Termination (cannot be ignored)
Application-defined signal 1
Application-defined signal 2
Terminal read from background process
Terminal write from background process
Urgent condition on socket
val catch_break : bool -> unitcatch_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.
val ocaml_version : stringocaml_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.
val development_version : booltrue if this is a development version, false otherwise.
type ocaml_release_info = { major : int; minor : int; patchlevel : int; } ocaml_release is the version of OCaml.
val enable_runtime_warnings : bool -> unitControl 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.
val runtime_warnings_enabled : unit -> boolReturn whether runtime warnings are currently enabled.
val opaque_identity : 'a -> 'a 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 ()))
+doneThis 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.
Id (ocaml.Stdlib.Type.Id) Up – ocaml » Stdlib » Type » IdThe type for identifiers for type 'a.
make () is a new type identifier.
uid id is a runtime unique identifier for id.
val provably_equal : 'a t -> 'b t -> ('a , 'b ) eq provably_equal i0 i1 is Some Equal if identifier i0 is equal to i1 and None otherwise.
The following shows how type identifiers can be used to implement a simple heterogeneous key-value dictionary. In contrast to Stdlib.Map
(** Heterogeneous dictionaries. *)
+module Dict : sig
+ type t
+ (** The type for dictionaries. *)
+
+ type 'a key
+ (** The type for keys binding values of type ['a]. *)
+
+ val key : unit -> 'a key
+ (** [key ()] is a new dictionary key. *)
+
+ val empty : t
+ (** [empty] is the empty dictionary. *)
+
+ val add : 'a key -> 'a -> t -> t
+ (** [add k v d] is [d] with [k] bound to [v]. *)
+
+ val remove : 'a key -> t -> t
+ (** [remove k d] is [d] with the last binding of [k] removed. *)
+
+ val find : 'a key -> t -> 'a option
+ (** [find k d] is the binding of [k] in [d], if any. *)
+end = struct
+ type 'a key = 'a Type.Id.t
+ type binding = B : 'a key * 'a -> binding
+ type t = (int * binding) list
+
+ let key () = Type.Id.make ()
+ let empty = []
+ let add k v d = (Type.Id.uid k, B (k, v)) :: d
+ let remove k d = List.remove_assoc (Type.Id.uid k) d
+ let find : type a. a key -> t -> a option = fun k d ->
+ match List.assoc_opt (Type.Id.uid k) d with
+ | None -> None
+ | Some (B (k', v)) ->
+ match Type.Id.provably_equal k k' with
+ | Some Type.Equal -> Some v
+ | None -> assert false
+endType (ocaml.Stdlib.Type) Up – ocaml » Stdlib » TypeModule Stdlib.Type Type introspection.
type (_, _) eq = | Equal : ('a , 'a ) eq The purpose of eq is to represent type equalities that may not otherwise be known by the type checker (e.g. because they may depend on dynamic data).
A value of type (a, b) eq represents the fact that types a and b are equal.
If one has a value eq : (a, b) eq that proves types a and b are equal, one can use it to convert a value of type a to a value of type b by pattern matching on Equal:
let cast (type a) (type b) (Equal : (a, b) Type.eq) (a : a) : b = aAt runtime, this function simply returns its second argument unchanged.
Uchar (ocaml.Stdlib.Uchar) Up – ocaml » Stdlib » UcharModule Stdlib.Uchar Unicode 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.
succ u is the scalar value after u in the set of Unicode scalar values.
pred u is the scalar value before u in the set of Unicode scalar values.
val is_valid : int -> boolis_valid n is true if and only if n is a Unicode scalar value (i.e. in the ranges 0x0000...0xD7FF or 0xE000...0x10FFFF).
of_int i is i as a Unicode character.
to_int u is u as an integer.
is_char u is true if and only if u is a latin1 OCaml character.
of_char c is c as a Unicode character.
to_char u is u as an OCaml latin1 character.
val equal : t -> t -> val compare : t -> t -> compare u u' is Stdlib.compare u u'.
hash 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.
utf_decode_is_valid d is true if and only if d holds a valid decode.
utf_decode_uchar d is the Unicode character decoded by d if utf_decode_is_valid d is true and Uchar.rep
utf_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.
utf_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).
utf_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
val utf_8_byte_length : t -> utf_8_byte_length u is the number of bytes needed to encode u in UTF-8.
val utf_16_byte_length : t -> utf_16_byte_length u is the number of bytes needed to encode u in UTF-16.
Unit (ocaml.Stdlib.Unit) Up – ocaml » Stdlib » UnitModule Stdlib.Unit Unit 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 equal : t -> t -> val compare : t -> t -> val to_string : t -> H (ocaml.Stdlib.Weak.Make.H) Up – ocaml » Stdlib » Weak » Make » HThe type of the hashtable keys.
val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash Make (ocaml.Stdlib.Weak.Make) Up – ocaml » Stdlib » Weak » MakeThe 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_valueMarshal
create n creates a new empty weak hash set, of initial size n. The table will grow as needed.
Remove 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.
val add : t -> data -> 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.
val remove : t -> data -> remove t x removes from t one instance of x. Does nothing if there is no instance of x in t.
find t x returns an instance of x found 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.
val mem : t -> data -> mem t x returns true if there is at least one instance of x in t, false otherwise.
val iter : (data -> -> t -> 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.
val fold : (data -> 'acc -> 'acc ) -> t -> 'acc -> 'acc 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.
Count 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 -> Return 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.
Weak (ocaml.Stdlib.Weak) Up – ocaml » Stdlib » WeakThe 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:
Integers are not allocated and cannot be stored in weak arrays. Weak arrays cannot be marshaled using Stdlib.output_valueMarshal Weak.create n returns a new weak array of length n. All the pointers are initially empty.
Weak.length ar returns the length (number of elements) of ar.
val set : 'a t -> int -> 'a option-> Weak.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-> Weak.fill ar ofs len el sets to el all pointers of ar from ofs to ofs + len - 1.
val blit : 'a t -> int -> 'a t -> int -> int -> unitWeak.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.HashedTypeequal 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.
Unsynchronized accesses
Unsynchronized accesses to weak hash sets are a programming error. Unsynchronized accesses to a weak hash set may lead to an invalid weak hash set state. Thus, concurrent accesses to weak hash sets must be synchronized (for instance with a Mutex.t
module type S = sig ... end The output signature of the functor Weak.Make
Functor 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.
S (ocaml.Stdlib.Weak.S) Up – ocaml » Stdlib » Weak » SThe 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_valueMarshal
create n creates a new empty weak hash set, of initial size n. The table will grow as needed.
Remove 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.
val add : t -> data -> 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.
val remove : t -> data -> remove t x removes from t one instance of x. Does nothing if there is no instance of x in t.
find t x returns an instance of x found 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.
val mem : t -> data -> mem t x returns true if there is at least one instance of x in t, false otherwise.
val iter : (data -> -> t -> 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.
val fold : (data -> 'acc -> 'acc ) -> t -> 'acc -> 'acc 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.
Count 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 -> Return 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 (ocaml.Stdlib) Up – ocaml » StdlibModule Stdlib The 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.
In 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 .
Raise the given exception value
val raise_notrace : exn -> 'a A faster version raise which does not record the backtrace.
val invalid_arg : string -> 'a Raise exception Invalid_argument with the given string.
val failwith : string -> 'a Raise exception Failure with the given string.
The Exit exception is not raised by any library function. It is provided for use in your programs.
exception Match_failure of string * int * intException 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 Assert_failure of string * int * intException 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 Invalid_argument of stringException 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 Failure of stringException 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 search functions when the desired object could not be found.
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 Sys_error of stringException 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 Division_by_zero 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 Undefined_recursive_module of string * int * intException 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).
val (=) : 'a -> 'a -> 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.
val (<>) : 'a -> 'a -> Negation of Stdlib.(=)Ocaml_operators for more information.
val (<) : 'a -> 'a -> See Stdlib.(>=)Ocaml_operators for more information.
val (>) : 'a -> 'a -> See Stdlib.(>=)Ocaml_operators for more information.
val (<=) : 'a -> 'a -> See Stdlib.(>=)Ocaml_operators for more information.
val (>=) : 'a -> 'a -> 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.
val compare : 'a -> 'a -> 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.nannan 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.MakeMap.MakeList.sortArray.sort
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.
val (==) : 'a -> 'a -> 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.
val (!=) : 'a -> 'a -> Negation of Stdlib.(==)Ocaml_operators for more information.
val (&&) : bool -> bool -> boolThe 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.
val (||) : bool -> bool -> boolThe 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".
__FILE__ returns the name of the file currently being parsed by the compiler.
__LINE__ returns the line number at which this expression appears in the file currently being parsed by the compiler.
__MODULE__ returns the module name of the file being parsed by the compiler.
val __POS__ : string * int * int * int__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.
val __FUNCTION__ : string__FUNCTION__ returns the name of the current function or method, including any enclosing modules or classes.
val __LOC_OF__ : 'a -> 'a __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".
val __LINE_OF__ : 'a -> 'a __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.
val __POS_OF__ : 'a -> (string * int * int * int) * 'a __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.
val (|>) : 'a -> ('a -> 'b ) -> 'b Reverse-application operator: x |> f |> g is exactly equivalent to g (f (x)). Left-associative operator, see Ocaml_operators for more information.
val (@@) : ('a -> 'b ) -> 'a -> 'b 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
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.
val (+) : int -> int -> intInteger addition. Left-associative operator, see Ocaml_operators for more information.
val (-) : int -> int -> intInteger subtraction. Left-associative operator, , see Ocaml_operators for more information.
val (*) : int -> int -> intInteger multiplication. Left-associative operator, see Ocaml_operators for more information.
val (/) : int -> int -> intInteger 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.
val (mod) : int -> int -> intInteger 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.
abs x is the absolute value of x. On min_int this is min_int itself and thus remains negative.
The greatest representable integer.
The smallest representable integer.
val (land) : int -> int -> intBitwise logical and. Left-associative operator, see Ocaml_operators for more information.
val (lor) : int -> int -> intBitwise logical or. Left-associative operator, see Ocaml_operators for more information.
val (lxor) : int -> int -> intBitwise logical exclusive or. Left-associative operator, see Ocaml_operators for more information.
Bitwise logical negation.
val (lsl) : int -> int -> intn 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.
val (lsr) : int -> int -> intn 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.
val (asr) : int -> int -> intn 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, ...
val (~-.) : float -> floatUnary negation. You can also write -. e instead of ~-. e. Unary operator, see Ocaml_operators for more information.
val (~+.) : float -> floatUnary addition. You can also write +. e instead of ~+. e. Unary operator, see Ocaml_operators for more information.
val (+.) : float -> float -> floatFloating-point addition. Left-associative operator, see Ocaml_operators for more information.
val (-.) : float -> float -> floatFloating-point subtraction. Left-associative operator, see Ocaml_operators for more information.
val (*.) : float -> float -> floatFloating-point multiplication. Left-associative operator, see Ocaml_operators for more information.
val (/.) : float -> float -> floatFloating-point division. Left-associative operator, see Ocaml_operators for more information.
val (**) : float -> float -> floatExponentiation. Right-associative operator, see Ocaml_operators for more information.
val sqrt : float -> floatval log10 : float -> floatval expm1 : float -> floatexpm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.
val log1p : float -> floatlog1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.
Cosine. Argument is in radians.
Sine. Argument is in radians.
Tangent. Argument is in radians.
val acos : float -> floatArc cosine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between 0.0 and pi.
val asin : float -> floatArc sine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between -pi/2 and pi/2.
val atan : float -> floatArc tangent. Result is in radians and is between -pi/2 and pi/2.
val atan2 : float -> float -> floatatan2 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.
val hypot : float -> float -> floathypot 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.
val cosh : float -> floatHyperbolic cosine. Argument is in radians.
val sinh : float -> floatHyperbolic sine. Argument is in radians.
val tanh : float -> floatHyperbolic tangent. Argument is in radians.
val acosh : float -> floatHyperbolic arc cosine. The argument must fall within the range [1.0, inf]. Result is in radians and is between 0.0 and inf.
val asinh : float -> floatHyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
val atanh : float -> floatHyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]. Result is in radians and ranges over the entire real line.
val ceil : float -> floatRound 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.
val floor : float -> floatRound 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.
val abs_float : float -> floatabs_float f returns the absolute value of f.
val copysign : float -> float -> floatcopysign 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.
val mod_float : float -> float -> floatmod_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.
val frexp : float -> float * intfrexp 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.
val ldexp : float -> int -> floatldexp x n returns x *. 2 ** n.
val modf : float -> float * floatmodf f returns the pair of the fractional and integral part of f.
val float_of_int : int -> floatConvert an integer to floating-point.
val truncate : float -> intval int_of_float : float -> intTruncate 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, unless otherwise specified in IEEE 754 standard. As for floating-point comparisons, =, <, <=, > and >= return false and <> returns true if one or both of their arguments is nan.
nan is a quiet NaN since 5.1; it was a signaling NaN before.
The largest positive finite value of type float.
The smallest positive, non-zero, non-denormalized value of type float.
val epsilon_float : floatThe difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0.
type fpclass = | FP_normal Normal number, none of the below
| FP_subnormal Number very close to 0.0, has reduced precision
| FP_zero | FP_infinite Number is positive or negative infinity
| FP_nan Not a number: result of an undefined operation
val classify_float : float -> fpclass Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
More string operations are provided in module String
val (^) : string -> string -> stringString concatenation. Right-associative operator, see Ocaml_operators for more information.
More character operations are provided in module Char
val int_of_char : char -> intReturn the ASCII code of the argument.
val char_of_int : int -> charReturn the character with the given ASCII code.
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.
val string_of_bool : bool -> stringReturn the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
val bool_of_string_opt : string -> bool option Convert the given string to a boolean.
Return None if the string is not "true" or "false".
val bool_of_string : string -> boolval string_of_int : int -> stringReturn the string representation of an integer, in decimal.
val int_of_string_opt : string -> int option 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_intmin_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.
val int_of_string : string -> intval string_of_float : float -> stringReturn 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
val float_of_string_opt : string -> float option 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.
val float_of_string : string -> floatval fst : ('a * 'b ) -> 'a Return the first component of a pair.
val snd : ('a * 'b ) -> 'b Return the second component of a pair.
More list operations are provided in module List
val (@) : 'a list-> 'a list-> 'a listl0 @ l1 appends l1 to l0. Same function as List.appendOcaml_operators for more information.
Note: all input/output functions can raise Sys_error when the system calls they invoke fail.
The type of input channel.
The type of output channel.
The standard input for the process.
The standard output for the process.
The standard error output for the process.
val print_char : char -> unitPrint a character on standard output.
val print_string : string -> unitPrint a string on standard output.
val print_bytes : bytes -> unitPrint a byte sequence on standard output.
val print_int : int -> unitPrint an integer, in decimal, on standard output.
val print_float : float -> unitPrint a floating-point number, in decimal, on standard output.
The conversion of the number to a string uses string_of_float
val print_endline : string -> unitPrint a string, followed by a newline character, on standard output and flush standard output.
val print_newline : unit -> unitPrint a newline character on standard output, and flush standard output. This can be used to simulate line buffering of standard output.
val prerr_char : char -> unitPrint a character on standard error.
val prerr_string : string -> unitPrint a string on standard error.
val prerr_bytes : bytes -> unitPrint a byte sequence on standard error.
val prerr_int : int -> unitPrint an integer, in decimal, on standard error.
val prerr_float : float -> unitPrint a floating-point number, in decimal, on standard error.
The conversion of the number to a string uses string_of_float
val prerr_endline : string -> unitPrint a string, followed by a newline character on standard error and flush standard error.
val prerr_newline : unit -> unitPrint a newline character on standard error, and flush standard error.
val read_line : unit -> stringFlush 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.
val read_int_opt : unit -> int option 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.
val read_int : unit -> intval read_float_opt : unit -> float option 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.
val read_float : unit -> floattype open_flag = | Open_rdonly | Open_wronly | Open_append open for appending: always write at end of file.
| Open_creat create the file if it does not exist.
| Open_trunc empty the file if it already exists.
| Open_excl fail if Open_creat and the file already exists.
| Open_binary open in binary mode (no conversion).
| Open_text open in text mode (may perform conversions).
| Open_nonblock open in non-blocking mode.
Open 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.
Same as Stdlib.open_outStdlib.open_out
open_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_outStdlib.open_out_bin
Flush 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 flush_all : unit -> unitFlush all open output channels; ignore errors.
Write the character on the given output channel.
Write the string on the given output channel.
Write 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.
Write one 8-bit integer (as the single character with that code) on the given output channel. The given integer is taken modulo 256.
Write 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
Write 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_valueMarshalStdlib.output_valueMarshal.to_channel
seek_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.
Return 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.
Return 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.
Close 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.
Same as close_out, but ignore all errors.
set_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.
Open the named file for reading, and return a new input channel on that file, positioned at the beginning of the file.
Same as Stdlib.open_inStdlib.open_in
open_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_inStdlib.open_in_bin
Read one character from the given input channel.
Read 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.
input 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_inputlen characters.) Exception Invalid_argument "input" is raised if pos and len do not designate a valid range of buf.
really_input ic buf pos len reads len characters from channel ic, storing them in byte sequence buf, starting at character number pos.
really_input_string ic len reads len characters from channel ic and returns them in a new string.
Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Stdlib.output_binary_int
Read the representation of a structured value, as produced by Stdlib.output_valueMarshal.from_channelMarshal
seek_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.
Return 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.
Return 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.
Close 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.
Same 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.
Operations 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.
type 'a ref = { mutable contents : 'a ;} The type of references (mutable indirection cells) containing a value of type 'a.
Return a fresh reference containing the given value.
!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 -> r := 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 -> Increment the integer contained in the given reference. Equivalent to fun r -> r := succ !r.
val decr : int ref -> Decrement the integer contained in the given reference. Equivalent to fun r -> r := pred !r.
type ('a, 'b) result = | Ok of 'a | Error of 'b 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 ScanfPrintfFormat
Format strings are made of three kinds of entities:
conversions specifications , introduced by the special character '%' followed by one or more characters specifying what kind of argument to read or print,formatting indications , introduced by the special character '@' followed by one or more characters specifying how to read or print the argument,plain characters that are regular characters with usual lexical conventions. Plain characters specify string literals to be read in the input or printed in the output.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 ScanfPrintfFormat
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.formatterscanf-style functions from module Scanf'b is typically Scanf.Scanning.in_channelType 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.Converts 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
val (^^) :
+ ('a , 'b , 'c , 'd , 'e , 'f ) format6 -> ('f , 'b , 'c , 'e , 'g , 'h ) format6 -> ('a , 'b , 'c , 'd , 'g , 'h ) format6 f1 ^^ 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. The callbacks registered with Domain.at_exitStdlib.at_exit
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.
val at_exit : (unit -> unit) -> 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:
executes Stdlib.exit terminates, either normally or because of an uncaught exception executes the C function caml_shutdown. The functions are called in 'last in, first out' order: the function most recently added with at_exit is called first. Parsing of command line arguments.
module Array : sig ... end Large, multi-dimensional, numerical arrays.
module Bool : sig ... end module Bytes : sig ... end Byte sequence operations.
Byte sequence operations.
Registering OCaml values with the C runtime.
module Char : sig ... end Ephemerons and weak hash tables.
Operations on file names.
module Float : sig ... end Floating-point arithmetic.
Memory management control and statistics; finalised values.
Hash tables and hash functions.
module Int32 : sig ... end module Int64 : sig ... end module Lazy : sig ... end The run-time library for lexers generated by ocamllex.
module List : sig ... end Association tables over ordered types.
Marshaling of data structures.
module Mutex : sig ... end Locks for mutual exclusion.
Processor-native integers.
Operations on internal representations of values.
The run-time library for parsers generated by ocamlyacc.
Facilities for printing exceptions and inspecting current call stack.
Formatted output functions.
module Queue : sig ... end First-in first-out queues.
Pseudo-random number generators (PRNG).
module Scanf : sig ... end Formatted input functions.
module Stack : sig ... end Last-in first-out stacks.
Standard labeled libraries.
module Type : sig ... end module Uchar : sig ... end module Unit : sig ... end module Weak : sig ... end Arrays of weak pointers and hash sets of weak pointers.
Stdlib__Arg (ocaml.Stdlib__Arg) Up – ocaml » Stdlib__ArgStdlib__Array (ocaml.Stdlib__Array) Up – ocaml » Stdlib__ArrayStdlib__ArrayLabels (ocaml.Stdlib__ArrayLabels) Up – ocaml » Stdlib__ArrayLabelsModule Stdlib__ArrayLabels Stdlib__Atomic (ocaml.Stdlib__Atomic) Up – ocaml » Stdlib__AtomicStdlib__Bigarray (ocaml.Stdlib__Bigarray) Up – ocaml » Stdlib__BigarrayStdlib__Bool (ocaml.Stdlib__Bool) Up – ocaml » Stdlib__BoolStdlib__Buffer (ocaml.Stdlib__Buffer) Up – ocaml » Stdlib__BufferStdlib__Bytes (ocaml.Stdlib__Bytes) Up – ocaml » Stdlib__BytesStdlib__BytesLabels (ocaml.Stdlib__BytesLabels) Up – ocaml » Stdlib__BytesLabelsModule Stdlib__BytesLabels Stdlib__Callback (ocaml.Stdlib__Callback) Up – ocaml » Stdlib__CallbackStdlib__Char (ocaml.Stdlib__Char) Up – ocaml » Stdlib__CharStdlib__Complex (ocaml.Stdlib__Complex) Up – ocaml » Stdlib__ComplexStdlib__Condition (ocaml.Stdlib__Condition) Up – ocaml » Stdlib__ConditionStdlib__Digest (ocaml.Stdlib__Digest) Up – ocaml » Stdlib__DigestStdlib__Domain (ocaml.Stdlib__Domain) Up – ocaml » Stdlib__DomainStdlib__Effect (ocaml.Stdlib__Effect) Up – ocaml » Stdlib__EffectStdlib__Either (ocaml.Stdlib__Either) Up – ocaml » Stdlib__EitherStdlib__Ephemeron (ocaml.Stdlib__Ephemeron) Up – ocaml » Stdlib__EphemeronStdlib__Filename (ocaml.Stdlib__Filename) Up – ocaml » Stdlib__FilenameStdlib__Float (ocaml.Stdlib__Float) Up – ocaml » Stdlib__FloatStdlib__Format (ocaml.Stdlib__Format) Up – ocaml » Stdlib__FormatStdlib__Fun (ocaml.Stdlib__Fun) Up – ocaml » Stdlib__FunStdlib__Gc (ocaml.Stdlib__Gc) Up – ocaml » Stdlib__GcStdlib__Hashtbl (ocaml.Stdlib__Hashtbl) Up – ocaml » Stdlib__HashtblStdlib__In_channel (ocaml.Stdlib__In_channel) Up – ocaml » Stdlib__In_channelModule Stdlib__In_channel Stdlib__Int (ocaml.Stdlib__Int) Up – ocaml » Stdlib__IntStdlib__Int32 (ocaml.Stdlib__Int32) Up – ocaml » Stdlib__Int32Stdlib__Int64 (ocaml.Stdlib__Int64) Up – ocaml » Stdlib__Int64Stdlib__Lazy (ocaml.Stdlib__Lazy) Up – ocaml » Stdlib__LazyStdlib__Lexing (ocaml.Stdlib__Lexing) Up – ocaml » Stdlib__LexingStdlib__List (ocaml.Stdlib__List) Up – ocaml » Stdlib__ListStdlib__ListLabels (ocaml.Stdlib__ListLabels) Up – ocaml » Stdlib__ListLabelsModule Stdlib__ListLabels Stdlib__Map (ocaml.Stdlib__Map) Up – ocaml » Stdlib__MapStdlib__Marshal (ocaml.Stdlib__Marshal) Up – ocaml » Stdlib__MarshalStdlib__MoreLabels (ocaml.Stdlib__MoreLabels) Up – ocaml » Stdlib__MoreLabelsModule Stdlib__MoreLabels Stdlib__Mutex (ocaml.Stdlib__Mutex) Up – ocaml » Stdlib__MutexStdlib__Nativeint (ocaml.Stdlib__Nativeint) Up – ocaml » Stdlib__NativeintStdlib__Obj (ocaml.Stdlib__Obj) Up – ocaml » Stdlib__ObjStdlib__Oo (ocaml.Stdlib__Oo) Up – ocaml » Stdlib__OoStdlib__Option (ocaml.Stdlib__Option) Up – ocaml » Stdlib__OptionStdlib__Out_channel (ocaml.Stdlib__Out_channel) Up – ocaml » Stdlib__Out_channelModule Stdlib__Out_channel Stdlib__Parsing (ocaml.Stdlib__Parsing) Up – ocaml » Stdlib__ParsingStdlib__Printexc (ocaml.Stdlib__Printexc) Up – ocaml » Stdlib__PrintexcStdlib__Printf (ocaml.Stdlib__Printf) Up – ocaml » Stdlib__PrintfStdlib__Queue (ocaml.Stdlib__Queue) Up – ocaml » Stdlib__QueueStdlib__Random (ocaml.Stdlib__Random) Up – ocaml » Stdlib__RandomStdlib__Result (ocaml.Stdlib__Result) Up – ocaml » Stdlib__ResultStdlib__Scanf (ocaml.Stdlib__Scanf) Up – ocaml » Stdlib__ScanfStdlib__Semaphore (ocaml.Stdlib__Semaphore) Up – ocaml » Stdlib__SemaphoreStdlib__Seq (ocaml.Stdlib__Seq) Up – ocaml » Stdlib__SeqStdlib__Set (ocaml.Stdlib__Set) Up – ocaml » Stdlib__SetStdlib__Stack (ocaml.Stdlib__Stack) Up – ocaml » Stdlib__StackStdlib__StdLabels (ocaml.Stdlib__StdLabels) Up – ocaml » Stdlib__StdLabelsStdlib__String (ocaml.Stdlib__String) Up – ocaml » Stdlib__StringStdlib__StringLabels (ocaml.Stdlib__StringLabels) Up – ocaml » Stdlib__StringLabelsModule Stdlib__StringLabels Stdlib__Sys (ocaml.Stdlib__Sys) Up – ocaml » Stdlib__SysStdlib__Type (ocaml.Stdlib__Type) Up – ocaml » Stdlib__TypeStdlib__Uchar (ocaml.Stdlib__Uchar) Up – ocaml » Stdlib__UcharStdlib__Unit (ocaml.Stdlib__Unit) Up – ocaml » Stdlib__UnitStdlib__Weak (ocaml.Stdlib__Weak) Up – ocaml » Stdlib__WeakStr (ocaml.Str) Up – ocaml » StrThe Str
The type of compiled regular expressions.
Compile 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 -> regexp Same as regexp, but the compiled expression will match text in a case-insensitive way: uppercase and lowercase letters will be considered equivalent.
val quote : string -> stringStr.quote s returns a regexp string that matches exactly s and nothing else.
val regexp_string : string -> regexp Str.regexp_string s returns a regular expression that matches exactly s and nothing else.
val regexp_string_case_fold : string -> regexp Str.regexp_string_case_fold is similar to Str.regexp_string
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
val matched_string : string -> stringmatched_string s returns the substring of s that was matched by the last call to one of the following matching or searching functions:
provided that none of the following functions was called in between:
Note: 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.
val match_beginning : unit -> intmatch_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
val match_end : unit -> intmatch_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
val matched_group : int -> string -> stringmatched_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_stringn 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.
val group_beginning : int -> intgroup_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
val group_end : int -> intgroup_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
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
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
val replace_matched : string -> string -> stringreplace_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_strings must be the same string that was passed to the matching or searching function.
val split : regexp -> string -> string list split 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 list Same as Str.splitn substrings, where n is the extra integer parameter.
val split_delim : regexp -> string -> string list Same as Str.splitsplit_delim (regexp " ") " abc " returns [""; "abc"; ""], while split with the same arguments returns ["abc"].
val bounded_split_delim : regexp -> string -> int -> string list Same as Str.bounded_split
type split_result = | Text of string| Delim of stringSame as Str.split_delimDelim in the result list; the latter are tagged Text. For instance, full_split (regexp "[{}]") "{ab}" returns [Delim "{"; Text "ab"; Delim "}"].
Same as Str.bounded_split_delimDelim in the result list; the latter are tagged Text.
val string_before : string -> int -> stringstring_before s n returns the substring of all characters of s that precede position n (excluding the character at position n).
val string_after : string -> int -> stringstring_after s n returns the substring of all characters of s that follow position n (including the character at position n).
val first_chars : string -> int -> stringfirst_chars s n returns the first n characters of s. This is the same function as Str.string_before
val last_chars : string -> int -> stringlast_chars s n returns the last n characters of s.
_ (ocaml.Strmatch.Make._) Up – ocaml » Strmatch » Make » _Make (ocaml.Strmatch.Make) Up – ocaml » Strmatch » MakeStrmatch (ocaml.Strmatch) Up – ocaml » Strmatchmodule type I = sig ... end module Make (_ : I ) : sig ... end I (ocaml.Strmatch.I) Up – ocaml » Strmatch » IMap (ocaml.Strongly_connected_components.Make.Id.Map) Up – ocaml » Strongly_connected_components » Make » Id » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Strongly_connected_components.Make.Id.Set) Up – ocaml » Strongly_connected_components » Make » Id » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Strongly_connected_components.Make.Id.T) Up – ocaml » Strongly_connected_components » Make » Id » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Strongly_connected_components.Make.Id.Tbl) Up – ocaml » Strongly_connected_components » Make » Id » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Id (ocaml.Strongly_connected_components.Make.Id) Up – ocaml » Strongly_connected_components » Make » Idinclude Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
Make (ocaml.Strongly_connected_components.Make) Up – ocaml » Strongly_connected_components » MakeModule Strongly_connected_components.Make If (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.
type component = | Has_loop of Id.t list| No_loop of Id.t Strongly_connected_components (ocaml.Strongly_connected_components) Up – ocaml » Strongly_connected_componentsModule Strongly_connected_components Kosaraju's algorithm for strongly connected components.
Warning: this module is unstable and part of compiler-libs .
module type S = sig ... end Map (ocaml.Strongly_connected_components.S.Id.Map) Up – ocaml » Strongly_connected_components » S » Id » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Strongly_connected_components.S.Id.Set) Up – ocaml » Strongly_connected_components » S » Id » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Strongly_connected_components.S.Id.T) Up – ocaml » Strongly_connected_components » S » Id » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Strongly_connected_components.S.Id.Tbl) Up – ocaml » Strongly_connected_components » S » Id » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Id (ocaml.Strongly_connected_components.S.Id) Up – ocaml » Strongly_connected_components » S » Idinclude Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
S (ocaml.Strongly_connected_components.S) Up – ocaml » Strongly_connected_components » SModule type Strongly_connected_components.S If (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.
type component = | Has_loop of Id.t list| No_loop of Id.t Stypes (ocaml.Stypes) Up – ocaml » Stypesval dump : string option -> Lazy (ocaml.Subst.Lazy) Up – ocaml » Subst » LazySubst (ocaml.Subst) Up – ocaml » Substval reset_for_saving : unit -> unittype scoping = | Keep | Make_local | Rescope of intval compose : t -> t -> t module Lazy : sig ... end A (ocaml.Switch.CtxStore.A) Up – ocaml » Switch » CtxStore » ACtxStore (ocaml.Switch.CtxStore) Up – ocaml » Switch » CtxStoreArg (ocaml.Switch.Make.Arg) Up – ocaml » Switch » Make » Argval make_const : int -> arg val make_offset : arg -> int -> arg val make_switch : loc -> arg -> int array -> act array-> act val make_exit : int -> act Make (ocaml.Switch.Make) Up – ocaml » Switch » MakeA (ocaml.Switch.Store.A) Up – ocaml » Switch » Store » Aval compare_key : key -> key -> val make_key : t -> key optionStore (ocaml.Switch.Store) Up – ocaml » Switch » StoreSwitch (ocaml.Switch) Up – ocaml » Switchtype 'a shared = | Shared of 'a | Single of 'a type ('a, 'ctx) t_store = { act_get : unit -> 'a array act_get_shared : unit -> 'a shared act_store : 'ctx -> 'a -> act_store_shared : 'ctx -> 'a -> } module type Stored = sig ... end module type S = sig ... end CtxStored (ocaml.Switch.CtxStored) Up – ocaml » Switch » CtxStoredModule type Switch.CtxStored S (ocaml.Switch.S) Up – ocaml » Switch » Sval make_const : int -> arg val make_offset : arg -> int -> arg val make_switch : loc -> arg -> int array -> act array-> act val make_exit : int -> act Stored (ocaml.Switch.Stored) Up – ocaml » Switch » StoredModule type Switch.Stored val compare_key : key -> key -> val make_key : t -> key optionMap (ocaml.Symbol.Map) Up – ocaml » Symbol » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Symbol.Set) Up – ocaml » Symbol » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Symbol.T) Up – ocaml » Symbol » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Symbol.Tbl) Up – ocaml » Symbol » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Symbol (ocaml.Symbol) Up – ocaml » SymbolModule Symbol A symbol identifies a constant provided by either:
another compilation unit; or a top-level module. * 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.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val compare_lists : t list-> t list-> Symtable (ocaml.Symtable) Up – ocaml » Symtableval require_primitive : string -> unitval data_primitive_names : unit -> stringval update_global_table : unit -> unitval is_global_defined : Ident.t -> val get_global_position : Ident.t -> type error = | Undefined_global of string| Unavailable_primitive of string| Wrong_vm of string| Uninitialized_global of stringSyntaxerr (ocaml.Syntaxerr) Up – ocaml » SyntaxerrModule Syntaxerr Auxiliary type for reporting syntax errors
Warning: this module is unstable and part of compiler-libs .
Map (ocaml.Tag.Map) Up – ocaml » Tag » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Tag.Set) Up – ocaml » Tag » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Tag.T) Up – ocaml » Tag » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Tag.Tbl) Up – ocaml » Tag » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Tag (ocaml.Tag) Up – ocaml » Taginclude Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash val create_exn : int -> t val compare : t -> t -> Targetint (ocaml.Targetint) Up – ocaml » TargetintModule Targetint Target 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 .
The type of target integers.
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.(/)
val unsigned_div : t -> t -> t Same as divunsigned 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.
val unsigned_rem : t -> t -> t Same as remunsigned integers.
Successor. Targetint.succ x is Targetint.add x Targetint.one.
Predecessor. Targetint.pred x is Targetint.sub x Targetint.one.
abs x is the absolute value of x. On min_int this is min_int itself and thus remains negative.
The size in bits of a target native integer.
The greatest representable target integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
The smallest representable target integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
Bitwise logical exclusive or.
Bitwise logical negation.
val shift_left : t -> int -> t 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.
val shift_right : t -> int -> t 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.
val shift_right_logical : t -> int -> t 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.
Convert the given integer (type int) to a target integer (type t), module the target word size.
val of_int_exn : int -> t Convert the given integer (type int) to a target integer (type t). Raises a fatal error if the conversion is not exact.
Convert the given target integer (type t) to an integer (type int). The high-order bit is lost during the conversion.
val of_float : float -> t Convert 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_intTargetint.max_int
val to_float : t -> Convert the given target integer to a floating-point number.
val of_int32 : int32 -> t Convert the given 32-bit integer (type int32) to a target integer.
val to_int32 : t -> Convert 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 -> t Convert the given 64-bit integer (type int64) to a target integer.
val to_int64 : t -> Convert the given target integer to a 64-bit integer (type int64).
val of_string : string -> t Convert 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 -> Return the string representation of its argument, in decimal.
val compare : t -> t -> The comparison function for target integers, with the same specification as Stdlib.comparet, this function compare allows the module Targetint to be passed as argument to the functors Set.Make and Map.Make.
val unsigned_compare : t -> t -> Same as compareunsigned integers.
val equal : t -> t -> The equal function for target ints.
type repr = | Int32 of int32| Int64 of int64The concrete representation of a native integer.
Print a target integer to a formatter.
Tast_iterator (ocaml.Tast_iterator) Up – ocaml » Tast_iteratorTast_mapper (ocaml.Tast_mapper) Up – ocaml » Tast_mapperTerminfo (ocaml.Terminfo) Up – ocaml » Terminfotype status = | Uninitialised | Bad_term | Good_term Thread (ocaml.Thread) Up – ocaml » ThreadThe type of thread handles.
val create : ('a -> 'b ) -> 'a -> t Thread.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 domain. 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.Exitfunct arg is discarded and not directly accessible to the parent thread.
See also Domain.spawn if you want parallel execution instead.
Return the handle for the thread currently executing.
Return 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 raised by user code to initiate termination of the current thread. In a thread created by Thread.createfunct arg, if the Thread.Exitfunct arg, it has the effect of terminating the current thread silently. In other contexts, there is no implicit handling of the Thread.Exit
Raise the Thread.ExitThread.createFun.protect finalizers and catch-all exception handlers will be executed.
To make it clear that an exception is raised and will trigger finalizers and catch-all exception handlers, it is recommended to write raise Thread.Exit instead of Thread.exit ().
val delay : float -> unitdelay d suspends the execution of the calling thread for d seconds. The other program threads continue to run during this time.
join 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 UnixUnix
Suspend 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
Same function as Unix.selectUnix.select
Same function as Unix.waitpidwait_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
sigmask 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.
val wait_signal : int list -> 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.
val default_uncaught_exception_handler : exn -> unitThread.default_uncaught_exception_handler will print the thread's id, exception and backtrace (if available).
val set_uncaught_exception_handler : (exn -> unit) -> 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
Tmc (ocaml.Tmc) Up – ocaml » TmcTMC (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.
Topcommon (ocaml.Topcommon) Up – ocaml » TopcommonModule Topcommon This 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.
type evaluation_outcome = | Result of Stdlib.Obj.t | Exception of exnval backtrace : string option ref val refill_lexbuf : bytes -> int -> intTopdirs (ocaml.Topdirs) Up – ocaml » Topdirsval dir_quit : unit -> unitval dir_directory : string -> unitval dir_remove_directory : string -> unitval dir_cd : string -> unitval section_general : stringval section_print : stringval section_trace : stringval section_options : stringval section_undocumented : stringTopeval (ocaml.Topeval) Up – ocaml » TopevalModule Topeval This 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.
diff --git a/ocaml/Tophooks/index.html b/ocaml/Tophooks/index.html
new file mode 100644
index 00000000..8d2b019e
--- /dev/null
+++ b/ocaml/Tophooks/index.html
@@ -0,0 +1,6 @@
+
+Tophooks (ocaml.Tophooks) Up – ocaml » TophooksToploop (ocaml.Toploop) Up – ocaml » Toplooptype directive_fun = | Directive_none of unit -> unit| Directive_string of string -> unit| Directive_int of int -> unit| Directive_ident of Longident.t -> | Directive_bool of bool -> unittype directive_info = { section : string; doc : string; } val all_directive_names : unit -> string list val initialize_toplevel_env : unit -> unitval record_backtrace : unit -> unittype ('a, 'b) gen_printer = | Zero of 'b | Succ of 'a -> ('a , 'b ) gen_printer val remove_printer : Path.t -> val max_printer_depth : int ref val max_printer_steps : int ref val toplevel_startup_hook : (unit -> unit) ref type event += | Startup | After_setup val add_hook : (event -> -> val run_hooks : event -> val override_sys_argv : string array -> Topmain (ocaml.Topmain) Up – ocaml » TopmainTopprinters (ocaml.Topprinters) Up – ocaml » TopprintersTopstart (ocaml.Topstart) Up – ocaml » Topstart
diff --git a/ocaml/Trace/index.html b/ocaml/Trace/index.html
new file mode 100644
index 00000000..2d842afb
--- /dev/null
+++ b/ocaml/Trace/index.html
@@ -0,0 +1,10 @@
+
+Trace (ocaml.Trace) Up – ocaml » TraceTranslattribute (ocaml.Translattribute) Up – ocaml » TranslattributeTranslclass (ocaml.Translclass) Up – ocaml » Translclasstype error = | Tags of string * stringTranslcore (ocaml.Translcore) Up – ocaml » Translcoretype error = | Free_super_var | Unreachable_reached Translmod (ocaml.Translmod) Up – ocaml » Translmodval toplevel_name : Ident.t -> type unsafe_component = | Unsafe_module_binding | Unsafe_functor | Unsafe_non_function | Unsafe_typext type error = | Circular_dependency of (Ident.t * unsafe_info ) list| Conflicting_inline_attributes Translobj (ocaml.Translobj) Up – ocaml » Translobjval reset_labels : unit -> unitTranslprim (ocaml.Translprim) Up – ocaml » Translprimval add_exception_ident : Ident.t -> val remove_exception_ident : Ident.t -> val clear_used_primitives : unit -> unitval get_used_primitives : unit -> Path.t listtype error = | Unknown_builtin_primitive of string| Wrong_arity_builtin_primitive of stringTraverse_for_exported_symbols (ocaml.Traverse_for_exported_symbols) Up – ocaml » Traverse_for_exported_symbolsModule Traverse_for_exported_symbols Computes 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). *
Violation (ocaml.Type_immediacy.Violation) Up – ocaml » Type_immediacy » ViolationModule Type_immediacy.Violation type t = | Not_always_immediate | Not_always_immediate_on_64bits Type_immediacy (ocaml.Type_immediacy) Up – ocaml » Type_immediacytype t = | Unknown | Always We know for sure that values of this type are always immediate
| Always_on_64bits We know for sure that values of this type are always immediate on 64 bit platforms. For other platforms, we know nothing.
coerce 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.
Return the immediateness of a type as indicated by the user via attributes
Typeclass (ocaml.Typeclass) Up – ocaml » Typeclasstype kind = | Object | Class | Class_type Datatype_kind (ocaml.Typecore.Datatype_kind) Up – ocaml » Typecore » Datatype_kindModule Typecore.Datatype_kind type t = | Record | Variant val type_name : t -> val label_name : t -> Typecore (ocaml.Typecore) Up – ocaml » Typecoretype type_forcing_context = | If_conditional | If_no_else_branch | While_loop_conditional | While_loop_body | For_loop_start_index | For_loop_stop_index | For_loop_body | Assert_condition | Sequence_left_hand_side | When_guard type wrong_kind_sort = | Constructor | Record | Boolean | List | Unit type existential_restriction = | At_toplevel no existential types at the toplevel
| In_group | In_rec | With_attributes or let[@any_attribute] = ...
| In_class_args or in class arguments class c (...) = ...
| In_class_def or in class c = let ... in ...
| In_self_pattern type module_patterns_restriction = | Modules_allowed of { scope : int; } | Modules_rejected
val reset_delayed_checks : unit -> unitval force_delayed_checks : unit -> unitTypedecl (ocaml.Typedecl) Up – ocaml » Typedecltype native_repr_kind = | Unboxed | Untagged Typedecl_immediacy (ocaml.Typedecl_immediacy) Up – ocaml » Typedecl_immediacyModule Typedecl_immediacy Typedecl_properties (ocaml.Typedecl_properties) Up – ocaml » Typedecl_propertiesModule Typedecl_properties An 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 -> 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 -> } 'prop represents the type of property values (Types.Variance.t
'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.
compute_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_separability (ocaml.Typedecl_separability) Up – ocaml » Typedecl_separabilityModule 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.
(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.
type error = | Non_separable_evar of string option Exception raised when a type declaration is not separable, or when its separability cannot be established.
type mode = Types.Separability.t = | Ind | Sep | Deepsep The 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).
compute_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
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_arrayInd as the mode of each parameter without any check.
Typedecl_unboxed (ocaml.Typedecl_unboxed) Up – ocaml » Typedecl_unboxedTypedecl_variance (ocaml.Typedecl_variance) Up – ocaml » Typedecl_variancetype surface_variance = bool * bool * bool type variance_variable_error = | No_variable | Variance_not_reflected | Variance_not_deducible Typedtree (ocaml.Typedtree) Up – ocaml » TypedtreeBy comparison with Parsetree
Every Longindent.t is accompanied by a resolved Path.t type partial = | Partial | Total type value = | Value_pattern type computation = | Computation_pattern
and 'k pattern_desc = | Tpat_any : value pattern_desc | Tpat_var : Ident.t * string Asttypes.loc -> value pattern_desc | Tpat_alias : value general_pattern Ident.t
+ * string Asttypes.loc -> value pattern_desc | Tpat_constant : Asttypes.constant -> value pattern_desc 1, 'a', "true", 1.0, 1l, 1L, 1n
| Tpat_tuple : value general_pattern -> value pattern_desc (P1, ..., Pn)
Invariant: n >= 2
| Tpat_construct : Longident.t Asttypes.loc Types.constructor_description
+ * value general_pattern (Ident.t Asttypes.loc core_type ) option-> value pattern_desc C (, 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 Types.row_desc ref -> value pattern_desc `A (None) `A P (Some P)
See Types.row_desc
| Tpat_record : (Longident.t Asttypes.loc Types.label_description
+ * value general_pattern
+ listAsttypes.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 -> value pattern_desc | Tpat_lazy : value general_pattern -> value pattern_desc | Tpat_value : tpat_value_argument -> computation pattern_desc P
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_desc | Tpat_or : 'k general_pattern 'k general_pattern Types.row_desc option-> 'k pattern_desc P1 | P2
row_desc = Some _ when translating Ppat_type _, None otherwise.
and expression_desc = | Texp_ident of Path.t * Longident.t Asttypes.loc Types.value_description | Texp_constant of Asttypes.constant 1, 'a', "true", 1.0, 1l, 1L, 1n
| Texp_let of Asttypes.rec_flag * value_binding listexpression let 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 partial : partial ; } Pexp_fun and Pexp_function both translate to Texp_function. See Parsetree
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 partial match 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 try E with P1 -> E1 | ... | PN -> EN
| Texp_tuple of expression list| 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 optionstring option Asttypes.loc Types.module_presence
+ * module_expr
+ * expression | Texp_letexception of extension_constructor * expression | Texp_assert of expression * Location.t | 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 * expression and module_type_constraint = | Tmodtype_implicit The module type constraint has been synthesized during typechecking.
| Tmodtype_explicit of module_type The module type was in the source file.
Annotations for Tmod_constraint.
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.
as_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).
Alpha conversion of patterns
Splits an or pattern into its value (left) and exception (right) parts.
Whether an expression looks nice as the subject of a sentence in a error message.
Sig_component_kind (ocaml.Typemod.Sig_component_kind) Up – ocaml » Typemod » Sig_component_kindModule Typemod.Sig_component_kind type t = | Value | Type | Module | Module_type | Extension_constructor | Class | Class_type val to_string : t -> Signature_names (ocaml.Typemod.Signature_names) Up – ocaml » Typemod » Signature_namesModule Typemod.Signature_names Typemod (ocaml.Typemod) Up – ocaml » TypemodModule Typemod Type-checking of the module language and typed ast hooks
Warning: this module is unstable and part of compiler-libs .
val initial_env :
+ loc :Location.t -> initially_opened_module :string option -> open_implicit_modules :string list -> Env.t Typeopt (ocaml.Typeopt) Up – ocaml » Typeoptval classify_lazy_argument :
+ Typedtree.expression -> [ `Constant_or_function
+ | `Float_that_cannot_be_shortcut
+ | `Identifier of [ `Forward_value | `Other ] | `Other ] value_kind_union k1 k2 is a value_kind at least as general as k1 and k2
MethSet (ocaml.Types.MethSet) Up – ocaml » Types » MethSetThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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, but returns the largest element of the given set.
val max_elt_opt : t -> elt optionSame 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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Meths (ocaml.Types.Meths) Up – ocaml » Types » MethsThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Separability (ocaml.Types.Separability) Up – ocaml » Types » Separabilitytype t = | Ind | Sep | Deepsep Modes 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
val compare : t -> t -> Compare two mode according to their mode ordering.
max_mode m1 m2 returns the most demanding mode. It is used to express the conjunction of two parameter mode constraints.
The '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 default_signature : arity :int -> signature The most pessimistic separability for a completely unknown type.
TransientTypeOps (ocaml.Types.TransientTypeOps) Up – ocaml » Types » TransientTypeOpsModule Types.TransientTypeOps Comparisons for functors
val compare : t -> t -> val equal : t -> t -> Transient_expr (ocaml.Types.Transient_expr) Up – ocaml » Types » Transient_exprCoerce without normalizing with repr
Instantiate a not yet instantiated stub. Fail if already instantiated.
VarSet (ocaml.Types.VarSet) Up – ocaml » Types » VarSetThe type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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, but returns the largest element of the given set.
val max_elt_opt : t -> elt optionSame 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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
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.)
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listval of_list : elt list-> t 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.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
Variance (ocaml.Types.Variance) Up – ocaml » Types » Variancetype f = | May_pos | May_neg | May_weak | Inj | Pos | Neg | Inv val subset : t -> t -> val set_if : bool -> f -> t -> t val compose : t -> t -> t val get_upper : t -> val get_lower : t -> val unknown_signature : injective :bool -> arity :int -> t listThe most pessimistic variance for a completely unknown type.
Vars (ocaml.Types.Vars) Up – ocaml » Types » VarsThe type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding, but returns the binding with the largest key in the given map.
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt, but returns the binding with the largest key in the given map.
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listval of_list : (key * 'a ) list-> 'a t of_list bs adds the bindings of bs to the empty map, in list order (if a key is bound twice in bs the last one takes over).
Iterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
Types (ocaml.Types) Up – ocaml » 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 option Tvar (Some "a") ==> 'a or '_a Tvar None ==> _
| Tarrow of Asttypes.arg_label * type_expr * type_expr * commutable Tarrow (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 listabbrev_memo ref Tconstr (`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 optionref Tobject (`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_expr Tfield ("foo", field_public, t, ts) ==> <...; foo : t; ts>
| Tnil | Tlink of type_expr Indirection 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_desc Representation of polymorphic variants, see row_desc.
| Tunivar of string option Occurrence 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 fixed_explanation = | Univar of type_expr The row type was bound to an univar
| Fixed_private | Reified of Path.t | Rigid The row type was made rigid during constraint verification
and abbrev_memo = | Mnil | Mcons of Asttypes.private_flag * Path.t * type_expr * type_expr * abbrev_memo Found 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 ref Abbreviations 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.
field_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).
type field_kind_view = | Fprivate | Fpublic | Fabsent Getters for type_expr; calls repr before answering a value
type 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
Operations on transient_expr
Functions and definitions moved from Btype
Create a type with a fresh id
Create a type with a fresh id and no scope
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 = _;
+ _ ; _
}
; _
}
get all fields at once; different from the old row_repr
type row_field_view = | Rpresent of type_expr option| Reither of bool * type_expr list| Rabsent Current contents of a row field
val changed_row_field_exts : row_field list-> (unit -> unit) -> and method_privacy = | Mpublic | Mprivate of field_kind and record_representation = | Record_regular | Record_float | Record_unboxed of bool| Record_inlined of int| Record_extension of Path.t and variant_representation = | Variant_regular | Variant_unboxed and type_transparence = | Type_public | Type_new | Type_private type visibility = | Exported | Hidden and module_presence = | Mp_present | Mp_absent and rec_status = | Trec_not | Trec_first | Trec_next and ext_status = | Text_first | Text_next | Text_exception and constructor_tag = | Cstr_constant of int| Cstr_block of int| Cstr_unboxed | Cstr_extension of Path.t * boolExtracts 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 backtrack : cleanup_abbrev :(unit -> unit) -> snapshot -> val undo_first_change_after : snapshot -> Functions to use when modifying a type (only Ctype?). The old values are logged and reverted on backtracking.
TyVarEnv (ocaml.Typetexp.TyVarEnv) Up – ocaml » Typetexp » TyVarEnvremoves all type variables from scope
val with_local_scope : (unit -> 'a ) -> 'a Evaluate in a narrowed type-variable scope
remember that a list of strings connotes univars; this must always be paired with a check_poly_univars.
Verify that the given univars are universally quantified, and return the list of variables. The type in which the univars are used must be generalised
Same as check_poly_univars, but instantiates the resulting type scheme (i.e. variables become Tvar rather than Tunivar)
Typetexp (ocaml.Typetexp) Up – ocaml » Typetexpval valid_tyvar_name : string -> boolUn_anf (ocaml.Un_anf) Up – ocaml » Un_anfExpand ANF-like constructs so that pattern matches in Cmmgen will work correctly.
Unbox_closures (ocaml.Unbox_closures) Up – ocaml » Unbox_closuresUnbox_free_vars_of_closures (ocaml.Unbox_free_vars_of_closures) Up – ocaml » Unbox_free_vars_of_closuresModule 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 (ocaml.Unbox_specialised_args) Up – ocaml » Unbox_specialised_argsModule 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.
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.
LargeFile (ocaml.Unix.LargeFile) Up – ocaml » Unix » LargeFileModule Unix.LargeFile File operations on large files. This sub-module provides 64-bit variants of the functions lseektruncateftruncatestatlstatfstatint64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
val truncate : string -> int64 -> unittype stats = { st_dev : int; st_ino : int; st_kind : file_kind ; st_perm : file_perm ; st_nlink : int; st_uid : int; st_gid : int; Group ID of the file's group
st_rdev : int; Device ID (if special file)
st_size : int64; st_atime : float; st_mtime : float; st_ctime : float; } val stat : string -> stats val lstat : string -> stats Unix (ocaml.Unix) Up – ocaml » UnixModule Unix Interface 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_messagehandle_unix_errorUnix_error
type error = | E2BIG | EACCES | EAGAIN Resource temporarily unavailable; try again
| EBADF | EBUSY | ECHILD | EDEADLK Resource deadlock would occur
| EDOM Domain error for math functions, etc.
| EEXIST | EFAULT | EFBIG | EINTR Function interrupted by signal
| EINVAL | EIO | EISDIR | EMFILE Too many open files by the process
| EMLINK | ENAMETOOLONG | ENFILE Too many open files in the system
| ENODEV | ENOENT No such file or directory
| ENOEXEC | ENOLCK | ENOMEM | ENOSPC | ENOSYS | ENOTDIR | ENOTEMPTY | ENOTTY Inappropriate I/O control operation
| ENXIO No such device or address
| EPERM | EPIPE | ERANGE | EROFS | ESPIPE Invalid seek e.g. on a pipe
| ESRCH | EXDEV | EWOULDBLOCK | EINPROGRESS Operation now in progress
| EALREADY Operation already in progress
| ENOTSOCK Socket operation on non-socket
| EDESTADDRREQ Destination address required
| EMSGSIZE | EPROTOTYPE Protocol wrong type for socket
| ENOPROTOOPT | EPROTONOSUPPORT | ESOCKTNOSUPPORT Socket type not supported
| EOPNOTSUPP Operation not supported on socket
| EPFNOSUPPORT Protocol family not supported
| EAFNOSUPPORT Address family not supported by protocol family
| EADDRINUSE | EADDRNOTAVAIL Can't assign requested address
| ENETDOWN | ENETUNREACH | ENETRESET Network dropped connection on reset
| ECONNABORTED Software caused connection abort
| ECONNRESET | ENOBUFS No buffer space available
| EISCONN Socket is already connected
| ENOTCONN | ESHUTDOWN Can't send after socket shutdown
| ETOOMANYREFS Too many references: can't splice
| ETIMEDOUT | ECONNREFUSED | EHOSTDOWN | EHOSTUNREACH | ELOOP Too many levels of symbolic links
| EOVERFLOW File size or position not representable
| EUNKNOWNERR of intThe 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_errorUnix.Unix_error
val error_message : error -> Return a string describing the given error code.
val handle_unix_error : ('a -> 'b ) -> 'a -> 'b handle_unix_error f x applies f to x and returns the result. If the exception Unix_error
val environment : unit -> string array 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.
val unsafe_environment : unit -> string array Return the process environment, as an array of strings with the format ``variable=value''. Unlike environmentunsafe_getenv
val getenv : string -> stringReturn the value associated to a variable in the process environment, unless the process has special privileges.
val unsafe_getenv : string -> stringReturn the value associated to a variable in the process environment.
Unlike getenv
val putenv : string -> string -> unitputenv 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 = | WEXITED of intThe process terminated normally by exit; the argument is the return code.
| WSIGNALED of intThe process was killed by a signal; the argument is the signal number.
| WSTOPPED of intThe process was stopped by a signal; the argument is the signal number.
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.
On Windows: only WEXITED is used (as there are no inter-process signals) but with specific return codes to indicate special termination causes. Look for NTSTATUS values in the Windows documentation to decode such error return codes. In particular, STATUS_ACCESS_VIOLATION error code is the 32-bit 0xC0000005: as Int32.of_int 0xC0000005 is -1073741819, WEXITED -1073741819 is the Windows equivalent of WSIGNALED Sys.sigsegv.
type wait_flag = | WNOHANG Do not block if no child has died yet, but immediately return with a pid equal to 0.
| WUNTRACED Report also the children that receive stop signals.
val execv : string -> string array -> 'a 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.
On Windows: the CRT simply spawns a new process and exits the current one. This will have unwanted consequences if e.g. another process is waiting on the current one. Using create_processopen_process_* functions instead is recommended.
val execve : string -> string array -> string array -> 'a Same as execv
val execvp : string -> string array -> 'a Same as execv
val execvpe : string -> string array -> string array -> 'a Same as execve
Fork a new process. The returned integer is 0 for the child process, the pid of the child process for the parent process.
Wait until one of the children processes die, and return its pid and termination status.
Same as wait-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.
Execute 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.exitUnix._exitStdlib.at_exit
The typical use of Unix._exitUnix.fork
Return the pid of the process.
val getppid : unit -> intReturn the pid of the parent process.
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.
The abstract type of file descriptors.
File descriptor for standard input.
File descriptor for standard output.
File descriptor for standard error.
type open_flag = | O_RDONLY | O_WRONLY | O_RDWR Open for reading and writing
| O_NONBLOCK Open in non-blocking mode
| O_APPEND | O_CREAT | O_TRUNC Truncate to 0 length if existing
| O_EXCL | O_NOCTTY Don't make this dev a controlling tty
| O_DSYNC Writes complete as `Synchronised I/O data integrity completion'
| O_SYNC Writes complete as `Synchronised I/O file integrity completion'
| O_RSYNC Reads complete as writes (depending on O_SYNC/O_DSYNC)
| O_SHARE_DELETE Windows only: allow the file to be deleted while still open
| O_CLOEXEC | O_KEEPEXEC Clear the close-on-exec flag. This is currently the default.
The type of file access rights, e.g. 0o640 is read and write for user, read for group, none for others
Open the named file with the given flags. Third argument is the permissions to give to the file if it is created (see umask
Flush 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 writesingle_write guarantees that no data has been written.
val write_substring : file_descr -> string -> int -> int -> intSame as write
val single_write_substring : file_descr -> string -> int -> int -> intSame as single_write
Create 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
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.
Create 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
Beware that output channels are buffered, so you may have to call Stdlib.flush
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
Return the descriptor corresponding to an input channel.
Return the descriptor corresponding to an output channel.
type seek_command = | SEEK_SET indicates positions relative to the beginning of the file
| SEEK_CUR indicates positions relative to the current position
| SEEK_END indicates positions relative to the end of the file
Positioning modes for lseek
Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file).
val truncate : string -> int -> unitTruncates the named file to the given size.
Truncates the file corresponding to the given descriptor to the given size.
type file_kind = | S_REG | S_DIR | S_CHR | S_BLK | S_LNK | S_FIFO | S_SOCK type stats = { st_dev : int; st_ino : int; st_kind : file_kind ; st_perm : file_perm ; st_nlink : int; st_uid : int; st_gid : int; Group ID of the file's group
st_rdev : int; Device ID (if special file)
st_size : int; st_atime : float; st_mtime : float; st_ctime : float; } The information returned by the stat
val stat : string -> stats Return the information for the named file.
val lstat : string -> stats Same as stat
Return the information for the file associated with the given descriptor.
Return true if the given file descriptor refers to a terminal or console window, false otherwise.
File operations on large files. This sub-module provides 64-bit variants of the functions lseektruncateftruncatestatlstatfstatint64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
Memory 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 openfilepos 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.
map_file
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. map_fileFailure 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.
val unlink : string -> unitRemoves the named file.
If the named file is a directory, raises:
EPERM on POSIX compliant systemEISDIR on Linux >= 2.1.132EACCESS on Windowsval rename : string -> string -> unitrename 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.
val link : ?follow :bool -> string -> string -> unitlink ?follow src dst creates a hard link named dst to the file named src.
val realpath : string -> stringrealpath p is an absolute pathname for p obtained by resolving all extra / characters, relative path segments and symbolic links.
type access_permission = | R_OK | W_OK | X_OK | F_OK Change the permissions of the named file.
Change the permissions of an opened file.
val chown : string -> int -> int -> unitChange the owner uid and owner gid of the named file.
Change the owner uid and owner gid of an opened file.
Set the process's file mode creation mask, and return the previous mask.
Check 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.
Return a new file descriptor referencing the same file as the given descriptor. See set_close_on_execcloexec optional argument.
dup2 src dst duplicates src to dst, closing dst if already opened. See set_close_on_execcloexec optional argument.
Set 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.
Clear the ``non-blocking'' flag on the given descriptor. See set_nonblock
Set 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.
Create a directory with the given permissions (see umask
val rmdir : string -> unitRemove an empty directory.
val chdir : string -> unitChange the process working directory.
val getcwd : unit -> stringReturn the name of the current working directory.
val chroot : string -> unitChange the process root directory.
The type of descriptors over opened directories.
Open a descriptor on a directory
Return the next entry in a directory.
Reposition the descriptor to the beginning of the directory
Close a directory descriptor.
Create 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_execcloexec optional argument.
Create a named pipe with the given permissions (see umask
create_process prog args stdin stdout stderr creates 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.stdoutstdout 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.
create_process_env prog args env stdin stdout stderr works as create_processenv specifies the environment passed to the program.
High-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. systemFilename.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_inopen_process_in
Same as open_process_inStdlib.flushopen_process_args_outopen_process_out
Same as open_process_outopen_process_argsopen_process
Similar to open_processopen_process_args_fullopen_process_full
open_process_args prog args runs the program prog with arguments args. Note that the first argument is by convention the filename of the program being executed, just like Sys.argv.(0). The new process executes concurrently with the current process. The standard input and output of the new process are redirected to pipes, which can be respectively read and written via the returned channels. The input channel is connected to the output of the program, and the output channel to the input of the program.
Warning: writes on output channels are buffered, hence be careful to call Stdlib.flush
The executable file prog is searched for 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_in : string -> string array -> in_channel Same as open_process_args
val open_process_args_out : string -> string array -> out_channel Similar to open_process_args
Close channels opened by open_process_in
Close channels opened by open_process_out
Close channels opened by open_process
Close channels opened by open_process_full
val symlink : ?to_dir :bool -> string -> string -> unitsymlink ?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
val has_symlink : unit -> boolReturns 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 readlink : string -> stringRead the contents of a symbolic link.
Wait 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_ULOCK | F_LOCK Lock a region for writing, and block if already locked
| F_TLOCK Lock a region for writing, or fail if already locked
| F_TEST Test a region for other process locks
| F_RLOCK Lock a region for reading, and block if already locked
| F_TRLOCK Lock a region for reading, or fail if already locked
lockf 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 lseeklen 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.
val kill : int -> int -> unitkill pid signal sends signal number signal to the process with id pid.
On Windows: only the Sys.sigkill signal is emulated.
type sigprocmask_command = | SIG_SETMASK | SIG_BLOCK | SIG_UNBLOCK sigprocmask 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.
val sigpending : unit -> int list Return the set of blocked signals that are currently pending.
val sigsuspend : int list -> 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.
Wait until a non-ignored, non-blocked signal is delivered.
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; tm_min : int; tm_hour : int; tm_mday : int; tm_mon : int; tm_year : int; tm_wday : int; Day of week (Sunday is 0)
tm_yday : int; tm_isdst : bool; Daylight time savings in effect
} The type representing wallclock time and calendar date.
Return the current time since 00:00:00 GMT, Jan. 1, 1970, in seconds.
val gettimeofday : unit -> floatSame as time
Convert a time in seconds, as returned by timemktime
val localtime : float -> tm Convert a time in seconds, as returned by timemktime
val mktime : tm -> tm Convert a date and time, specified by the tm argument, into a time in seconds, as returned by timetm_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.
Schedule a SIGALRM signal after the given number of seconds.
Stop execution for the given number of seconds.
val sleepf : float -> unitStop execution for the given number of seconds. Like sleep, but fractions of seconds are supported.
Return the execution times of the process.
On Windows: partially implemented, will not report timings for child processes.
val utimes : string -> float -> float -> unitSet 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_REAL decrements in real time, and sends the signal SIGALRM when expired.
| ITIMER_VIRTUAL decrements 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.
type interval_timer_status = { it_interval : float; it_value : float; Current value of the timer
} The type describing the status of an interval timer
Return the current status of the given interval timer.
setitimer 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.
val geteuid : unit -> intReturn the effective user id under which the process runs.
On Windows: always returns 1.
Set the real user id and effective user id for the process.
Return the group id of the user executing the process.
On Windows: always returns 1.
val getegid : unit -> intReturn the effective group id under which the process runs.
On Windows: always returns 1.
Set the real group id and effective group id for the process.
val getgroups : unit -> int array Return the list of groups to which the user executing the process belongs.
On Windows: always returns [|1|].
val setgroups : int array -> setgroups groups sets the supplementary group IDs for the calling process. Appropriate privileges are required.
val initgroups : string -> int -> unitinitgroups 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.
type group_entry = { gr_name : string; gr_passwd : string; gr_gid : int; gr_mem : string array ; } Structure of entries in the groups database.
val getlogin : unit -> stringReturn the login name of the user executing the process.
Find an entry in passwd with the given name.
Find an entry in group with the given name.
Find an entry in passwd with the given user id.
Find an entry in group with the given group id.
The abstract type of Internet addresses.
val inet_addr_of_string : string -> inet_addr Conversion 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 -> Return the printable representation of the given Internet address. See inet_addr_of_string
A special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
A special IPv4 address representing the host machine (127.0.0.1).
A special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
A special IPv6 address representing the host machine (::1).
Whether the given inet_addr is an IPv6 address.
type socket_domain = | PF_UNIX | PF_INET | PF_INET6 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 = | SOCK_STREAM | SOCK_DGRAM | SOCK_RAW | SOCK_SEQPACKET 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.
type sockaddr = | ADDR_UNIX of string| ADDR_INET of inet_addr * intThe 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.
Create 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_execcloexec optional argument.
val domain_of_sockaddr : sockaddr -> socket_domain Return the socket domain adequate for the given socket address.
Create a pair of unnamed sockets, connected together. See set_close_on_execcloexec optional argument.
Accept 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_execcloexec optional argument.
Bind a socket to an address.
Connect a socket to an address.
Set up a socket for receiving connection requests. The integer argument is the maximal number of pending requests.
type shutdown_command = | SHUTDOWN_RECEIVE | SHUTDOWN_SEND | SHUTDOWN_ALL The type of commands for shutdown.
Shutdown 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).
Return the address of the given socket.
Return the address of the host connected to the given socket.
type msg_flag = | MSG_OOB | MSG_DONTROUTE | MSG_PEEK Receive data from a connected socket.
Receive data from an unconnected socket.
Send data over a connected socket.
Same as send, but take the data from a string instead of a byte sequence.
Send data over an unconnected socket.
Same as sendto, but take the data from a string instead of a byte sequence.
type socket_bool_option = | SO_DEBUG Record debugging information
| SO_BROADCAST Permit sending of broadcast messages
| SO_REUSEADDR Allow reuse of local addresses for bind
| SO_KEEPALIVE | SO_DONTROUTE Bypass the standard routing algorithms
| SO_OOBINLINE Leave out-of-band data in line
| SO_ACCEPTCONN Report whether socket listening is enabled
| TCP_NODELAY Control the Nagle algorithm for TCP sockets
| IPV6_ONLY Forbid binding an IPv6 socket to an IPv4 address
| SO_REUSEPORT Allow reuse of address and port bindings
The socket options that can be consulted with getsockoptsetsockopttrue/false) value.
type socket_int_option = | SO_SNDBUF | SO_RCVBUF | SO_ERROR | SO_TYPE | SO_RCVLOWAT Minimum number of bytes to process for input operations
| SO_SNDLOWAT Minimum number of bytes to process for output operations
type socket_optint_option = | SO_LINGER Whether to linger on closed connections that have data present, and for how long (in seconds)
The socket options that can be consulted with getsockopt_optintsetsockopt_optintint option, with None meaning ``disabled''.
type socket_float_option = | SO_RCVTIMEO Timeout for input operations
| SO_SNDTIMEO Timeout for output operations
The socket options that can be consulted with getsockopt_floatsetsockopt_float
Return the current status of a boolean-valued option in the given socket.
Set or clear a boolean-valued option in the given socket.
Same as getsockopt
Same as setsockopt
Same as getsockoptint option.
Same as setsockoptint option.
Same as getsockopt
Same as setsockopt
Return the error condition associated with the given socket, and clear it.
Connect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call Stdlib.flush
The two channels returned by open_connection share a descriptor to a socket. Therefore, when the connection is over, you should call Stdlib.close_outStdlib.close_in
``Shut down'' a connection established with open_connectionUnix.open_connection
Establish 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
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_outUnix.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.
type protocol_entry = { p_name : string; p_aliases : string array ; p_proto : int; } Structure of entries in the protocols database.
type service_entry = { s_name : string; s_aliases : string array ; s_port : int; s_proto : string; } Structure of entries in the services database.
val gethostname : unit -> stringReturn the name of the local host.
Find an entry in hosts with the given name.
Find an entry in hosts with the given address.
Find an entry in protocols with the given name.
Find an entry in protocols with the given protocol number.
Find an entry in services with the given name.
Find an entry in services with the given service number.
type getaddrinfo_option = | AI_FAMILY of socket_domain Impose the given socket domain
| AI_SOCKTYPE of socket_type Impose the given socket type
| AI_PROTOCOL of intImpose the given protocol
| AI_NUMERICHOST Do not call name resolver, expect numeric IP address
| AI_CANONNAME Fill the ai_canonname field of the result
| AI_PASSIVE Set address to ``any'' address for use with bind
getaddrinfo host service opts returns a list of addr_infoopts 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
} type getnameinfo_option = | NI_NOFQDN Do not qualify local host names
| NI_NUMERICHOST Always return host as IP address
| NI_NAMEREQD Fail if host name cannot be determined
| NI_NUMERICSERV Always return service as port number
| NI_DGRAM Consider the service as UDP-based instead of the default TCP
getnameinfo 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;mutable c_inpck : bool;Enable parity check on input.
mutable c_istrip : bool;Strip 8th bit on input characters.
mutable c_inlcr : bool;mutable c_igncr : bool;mutable c_icrnl : bool;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;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;mutable c_parenb : bool;Enable parity generation and detection.
mutable c_parodd : bool;Specify odd parity instead of even.
mutable c_hupcl : bool;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;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).
} Return the status of the terminal referred to by the given file descriptor.
type setattr_when = | TCSANOW | TCSADRAIN | TCSAFLUSH Set 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.
Send 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).
Waits until all output written on the given file descriptor has been transmitted.
type flush_queue = | TCIFLUSH | TCOFLUSH | TCIOFLUSH Discard 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.
type flow_action = | TCOOFF | TCOON | TCIOFF | TCION Suspend 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.
Put the calling process in a new session and detach it from its controlling terminal.
LargeFile (ocaml.UnixLabels.LargeFile) Up – ocaml » UnixLabels » LargeFileModule UnixLabels.LargeFile File operations on large files. This sub-module provides 64-bit variants of the functions lseektruncateftruncatestatlstatfstatint64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
val truncate : string -> len :int64 -> type stats = Unix.LargeFile.stats = { st_dev : int; st_ino : int; st_kind : file_kind ; st_perm : file_perm ; st_nlink : int; st_uid : int; st_gid : int; Group ID of the file's group
st_rdev : int; Device ID (if special file)
st_size : int64; st_atime : float; st_mtime : float; st_ctime : float; } val stat : string -> stats val lstat : string -> stats UnixLabels (ocaml.UnixLabels) Up – ocaml » UnixLabelsModule UnixLabels Interface 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_messagehandle_unix_errorUnix_error
type error = Unix.error = | E2BIG | EACCES | EAGAIN Resource temporarily unavailable; try again
| EBADF | EBUSY | ECHILD | EDEADLK Resource deadlock would occur
| EDOM Domain error for math functions, etc.
| EEXIST | EFAULT | EFBIG | EINTR Function interrupted by signal
| EINVAL | EIO | EISDIR | EMFILE Too many open files by the process
| EMLINK | ENAMETOOLONG | ENFILE Too many open files in the system
| ENODEV | ENOENT No such file or directory
| ENOEXEC | ENOLCK | ENOMEM | ENOSPC | ENOSYS | ENOTDIR | ENOTEMPTY | ENOTTY Inappropriate I/O control operation
| ENXIO No such device or address
| EPERM | EPIPE | ERANGE | EROFS | ESPIPE Invalid seek e.g. on a pipe
| ESRCH | EXDEV | EWOULDBLOCK | EINPROGRESS Operation now in progress
| EALREADY Operation already in progress
| ENOTSOCK Socket operation on non-socket
| EDESTADDRREQ Destination address required
| EMSGSIZE | EPROTOTYPE Protocol wrong type for socket
| ENOPROTOOPT | EPROTONOSUPPORT | ESOCKTNOSUPPORT Socket type not supported
| EOPNOTSUPP Operation not supported on socket
| EPFNOSUPPORT Protocol family not supported
| EAFNOSUPPORT Address family not supported by protocol family
| EADDRINUSE | EADDRNOTAVAIL Can't assign requested address
| ENETDOWN | ENETUNREACH | ENETRESET Network dropped connection on reset
| ECONNABORTED Software caused connection abort
| ECONNRESET | ENOBUFS No buffer space available
| EISCONN Socket is already connected
| ENOTCONN | ESHUTDOWN Can't send after socket shutdown
| ETOOMANYREFS Too many references: can't splice
| ETIMEDOUT | ECONNREFUSED | EHOSTDOWN | EHOSTUNREACH | ELOOP Too many levels of symbolic links
| EOVERFLOW File size or position not representable
| EUNKNOWNERR of intThe 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_errorUnix.Unix_error
val error_message : error -> Return a string describing the given error code.
val handle_unix_error : ('a -> 'b ) -> 'a -> 'b handle_unix_error f x applies f to x and returns the result. If the exception Unix_error
val environment : unit -> string array 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.
val unsafe_environment : unit -> string array Return the process environment, as an array of strings with the format ``variable=value''. Unlike environmentunsafe_getenv
val getenv : string -> stringReturn the value associated to a variable in the process environment, unless the process has special privileges.
val unsafe_getenv : string -> stringReturn the value associated to a variable in the process environment.
Unlike getenv
val putenv : string -> string -> unitputenv 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 = | WEXITED of intThe process terminated normally by exit; the argument is the return code.
| WSIGNALED of intThe process was killed by a signal; the argument is the signal number.
| WSTOPPED of intThe process was stopped by a signal; the argument is the signal number.
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.
On Windows: only WEXITED is used (as there are no inter-process signals) but with specific return codes to indicate special termination causes. Look for NTSTATUS values in the Windows documentation to decode such error return codes. In particular, STATUS_ACCESS_VIOLATION error code is the 32-bit 0xC0000005: as Int32.of_int 0xC0000005 is -1073741819, WEXITED -1073741819 is the Windows equivalent of WSIGNALED Sys.sigsegv.
type wait_flag = Unix.wait_flag = | WNOHANG Do not block if no child has died yet, but immediately return with a pid equal to 0.
| WUNTRACED Report also the children that receive stop signals.
val execv : prog :string -> args :string array -> 'a 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.
On Windows: the CRT simply spawns a new process and exits the current one. This will have unwanted consequences if e.g. another process is waiting on the current one. Using create_processopen_process_* functions instead is recommended.
val execve : prog :string -> args :string array -> env :string array -> 'a Same as execv
val execvp : prog :string -> args :string array -> 'a Same as execv
val execvpe : prog :string -> args :string array -> env :string array -> 'a Same as execve
Fork a new process. The returned integer is 0 for the child process, the pid of the child process for the parent process.
Wait until one of the children processes die, and return its pid and termination status.
Same as wait-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.
Execute 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.exitUnix._exitStdlib.at_exit
The typical use of Unix._exitUnix.fork
Return the pid of the process.
val getppid : unit -> intReturn the pid of the parent process.
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.
The abstract type of file descriptors.
File descriptor for standard input.
File descriptor for standard output.
File descriptor for standard error.
type open_flag = Unix.open_flag = | O_RDONLY | O_WRONLY | O_RDWR Open for reading and writing
| O_NONBLOCK Open in non-blocking mode
| O_APPEND | O_CREAT | O_TRUNC Truncate to 0 length if existing
| O_EXCL | O_NOCTTY Don't make this dev a controlling tty
| O_DSYNC Writes complete as `Synchronised I/O data integrity completion'
| O_SYNC Writes complete as `Synchronised I/O file integrity completion'
| O_RSYNC Reads complete as writes (depending on O_SYNC/O_DSYNC)
| O_SHARE_DELETE Windows only: allow the file to be deleted while still open
| O_CLOEXEC | O_KEEPEXEC Clear the close-on-exec flag. This is currently the default.
The type of file access rights, e.g. 0o640 is read and write for user, read for group, none for others
Open the named file with the given flags. Third argument is the permissions to give to the file if it is created (see umask
Flush file buffers to disk.
val read : file_descr -> buf :bytes -> pos :int -> len :int -> read 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 -> write 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 -> Same as writesingle_write guarantees that no data has been written.
val write_substring : file_descr -> buf :string -> pos :int -> len :int -> Same as write
val single_write_substring :
+ file_descr -> buf :string -> pos :int -> len :int -> Same as single_write
Create 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
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.
Create 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
Beware that output channels are buffered, so you may have to call Stdlib.flush
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
Return the descriptor corresponding to an input channel.
Return the descriptor corresponding to an output channel.
type seek_command = Unix.seek_command = | SEEK_SET indicates positions relative to the beginning of the file
| SEEK_CUR indicates positions relative to the current position
| SEEK_END indicates positions relative to the end of the file
Positioning modes for lseek
Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file).
val truncate : string -> len :int -> Truncates the named file to the given size.
Truncates the file corresponding to the given descriptor to the given size.
type file_kind = Unix.file_kind = | S_REG | S_DIR | S_CHR | S_BLK | S_LNK | S_FIFO | S_SOCK type stats = Unix.stats = { st_dev : int; st_ino : int; st_kind : file_kind ; st_perm : file_perm ; st_nlink : int; st_uid : int; st_gid : int; Group ID of the file's group
st_rdev : int; Device ID (if special file)
st_size : int; st_atime : float; st_mtime : float; st_ctime : float; } The information returned by the stat
val stat : string -> stats Return the information for the named file.
val lstat : string -> stats Same as stat
Return the information for the file associated with the given descriptor.
Return true if the given file descriptor refers to a terminal or console window, false otherwise.
File operations on large files. This sub-module provides 64-bit variants of the functions lseektruncateftruncatestatlstatfstatint64) instead of regular integers (type int), thus allowing operating on files whose sizes are greater than max_int.
Memory 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 openfilepos 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.
map_file
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. map_fileFailure 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.
val unlink : string -> unitRemoves the named file.
If the named file is a directory, raises:
EPERM on POSIX compliant systemEISDIR on Linux >= 2.1.132EACCESS on Windowsval rename : src :string -> dst :string -> rename ~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.
val link : ?follow :bool -> src :string -> dst :string -> link ?follow ~src ~dst creates a hard link named dst to the file named src.
val realpath : string -> stringrealpath p is an absolute pathname for p obtained by resolving all extra / characters, relative path segments and symbolic links.
Change the permissions of the named file.
Change the permissions of an opened file.
val chown : string -> uid :int -> gid :int -> Change the owner uid and owner gid of the named file.
val fchown : file_descr -> uid :int -> gid :int -> Change the owner uid and owner gid of an opened file.
Set the process's file mode creation mask, and return the previous mask.
Check 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.
Return a new file descriptor referencing the same file as the given descriptor. See set_close_on_execcloexec optional argument.
dup2 ~src ~dst duplicates src to dst, closing dst if already opened. See set_close_on_execcloexec optional argument.
Set 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.
Clear the ``non-blocking'' flag on the given descriptor. See set_nonblock
Set 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.
Create a directory with the given permissions (see umask
val rmdir : string -> unitRemove an empty directory.
val chdir : string -> unitChange the process working directory.
val getcwd : unit -> stringReturn the name of the current working directory.
val chroot : string -> unitChange the process root directory.
The type of descriptors over opened directories.
Open a descriptor on a directory
Return the next entry in a directory.
Reposition the descriptor to the beginning of the directory
Close a directory descriptor.
Create 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_execcloexec optional argument.
val mkfifo : string -> perm :file_perm -> Create a named pipe with the given permissions (see umask
create_process ~prog ~args ~stdin ~stdout ~stderr creates 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.stdoutstdout 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 -> create_process_env ~prog ~args ~env ~stdin ~stdout ~stderr works as create_processenv specifies the environment passed to the program.
High-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. systemFilename.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_inopen_process_in
Same as open_process_inStdlib.flushopen_process_args_outopen_process_out
Same as open_process_outopen_process_argsopen_process
Similar to open_processopen_process_args_fullopen_process_full
open_process_args prog args runs the program prog with arguments args. Note that the first argument is by convention the filename of the program being executed, just like Sys.argv.(0). The new process executes concurrently with the current process. The standard input and output of the new process are redirected to pipes, which can be respectively read and written via the returned channels. The input channel is connected to the output of the program, and the output channel to the input of the program.
Warning: writes on output channels are buffered, hence be careful to call Stdlib.flush
The executable file prog is searched for 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_in : string -> string array -> in_channel Same as open_process_args
val open_process_args_out : string -> string array -> out_channel Similar to open_process_args
Close channels opened by open_process_in
Close channels opened by open_process_out
Close channels opened by open_process
Close channels opened by open_process_full
val symlink : ?to_dir :bool -> src :string -> dst :string -> 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
val has_symlink : unit -> boolReturns 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 readlink : string -> stringRead the contents of a symbolic link.
Wait 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_ULOCK | F_LOCK Lock a region for writing, and block if already locked
| F_TLOCK Lock a region for writing, or fail if already locked
| F_TEST Test a region for other process locks
| F_RLOCK Lock a region for reading, and block if already locked
| F_TRLOCK Lock a region for reading, or fail if already locked
lockf 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 lseeklen 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.
val kill : pid :int -> signal :int -> kill ~pid ~signal sends signal number signal to the process with id pid.
On Windows: only the Sys.sigkill signal is emulated.
sigprocmask ~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.
val sigpending : unit -> int list Return the set of blocked signals that are currently pending.
val sigsuspend : int list -> 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.
Wait until a non-ignored, non-blocked signal is delivered.
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; tm_min : int; tm_hour : int; tm_mday : int; tm_mon : int; tm_year : int; tm_wday : int; Day of week (Sunday is 0)
tm_yday : int; tm_isdst : bool; Daylight time savings in effect
} The type representing wallclock time and calendar date.
Return the current time since 00:00:00 GMT, Jan. 1, 1970, in seconds.
val gettimeofday : unit -> floatSame as time
Convert a time in seconds, as returned by timemktime
val localtime : float -> tm Convert a time in seconds, as returned by timemktime
val mktime : tm -> tm Convert a date and time, specified by the tm argument, into a time in seconds, as returned by timetm_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.
Schedule a SIGALRM signal after the given number of seconds.
Stop execution for the given number of seconds.
val sleepf : float -> unitStop execution for the given number of seconds. Like sleep, but fractions of seconds are supported.
Return the execution times of the process.
On Windows: partially implemented, will not report timings for child processes.
val utimes : string -> access :float -> modif :float -> 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_REAL decrements in real time, and sends the signal SIGALRM when expired.
| ITIMER_VIRTUAL decrements 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
Return the current status of the given interval timer.
setitimer 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.
val geteuid : unit -> intReturn the effective user id under which the process runs.
On Windows: always returns 1.
Set the real user id and effective user id for the process.
Return the group id of the user executing the process.
On Windows: always returns 1.
val getegid : unit -> intReturn the effective group id under which the process runs.
On Windows: always returns 1.
Set the real group id and effective group id for the process.
val getgroups : unit -> int array Return the list of groups to which the user executing the process belongs.
On Windows: always returns [|1|].
val setgroups : int array -> setgroups groups sets the supplementary group IDs for the calling process. Appropriate privileges are required.
val initgroups : string -> int -> unitinitgroups 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.
type group_entry = Unix.group_entry = { gr_name : string; gr_passwd : string; gr_gid : int; gr_mem : string array ; } Structure of entries in the groups database.
val getlogin : unit -> stringReturn the login name of the user executing the process.
Find an entry in passwd with the given name.
Find an entry in group with the given name.
Find an entry in passwd with the given user id.
Find an entry in group with the given group id.
The abstract type of Internet addresses.
val inet_addr_of_string : string -> inet_addr Conversion 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 -> Return the printable representation of the given Internet address. See inet_addr_of_string
A special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
A special IPv4 address representing the host machine (127.0.0.1).
A special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
A special IPv6 address representing the host machine (::1).
Whether the given inet_addr is an IPv6 address.
type socket_domain = Unix.socket_domain = | PF_UNIX | PF_INET | PF_INET6 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 = | SOCK_STREAM | SOCK_DGRAM | SOCK_RAW | SOCK_SEQPACKET 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.
Create 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_execcloexec optional argument.
val domain_of_sockaddr : sockaddr -> socket_domain Return the socket domain adequate for the given socket address.
Create a pair of unnamed sockets, connected together. See set_close_on_execcloexec optional argument.
Accept 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_execcloexec optional argument.
Bind a socket to an address.
Connect a socket to an address.
Set up a socket for receiving connection requests. The integer argument is the maximal number of pending requests.
The type of commands for shutdown.
Shutdown 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).
Return the address of the given socket.
Return the address of the host connected to the given socket.
type msg_flag = Unix.msg_flag = | MSG_OOB | MSG_DONTROUTE | MSG_PEEK val recv :
+ file_descr -> buf :bytes -> pos :int -> len :int -> mode :msg_flag list-> Receive data from a connected socket.
Receive data from an unconnected socket.
val send :
+ file_descr -> buf :bytes -> pos :int -> len :int -> mode :msg_flag list-> Send data over a connected socket.
val send_substring :
+ file_descr -> buf :string -> pos :int -> len :int -> mode :msg_flag list-> Same as send, but take the data from a string instead of a byte sequence.
Send data over an unconnected socket.
Same as sendto, but take the data from a string instead of a byte sequence.
type socket_bool_option = Unix.socket_bool_option = | SO_DEBUG Record debugging information
| SO_BROADCAST Permit sending of broadcast messages
| SO_REUSEADDR Allow reuse of local addresses for bind
| SO_KEEPALIVE | SO_DONTROUTE Bypass the standard routing algorithms
| SO_OOBINLINE Leave out-of-band data in line
| SO_ACCEPTCONN Report whether socket listening is enabled
| TCP_NODELAY Control the Nagle algorithm for TCP sockets
| IPV6_ONLY Forbid binding an IPv6 socket to an IPv4 address
| SO_REUSEPORT Allow reuse of address and port bindings
The socket options that can be consulted with getsockoptsetsockopttrue/false) value.
type socket_int_option = Unix.socket_int_option = | SO_SNDBUF | SO_RCVBUF | SO_ERROR | SO_TYPE | SO_RCVLOWAT Minimum number of bytes to process for input operations
| SO_SNDLOWAT Minimum number of bytes to process for output operations
type socket_optint_option = Unix.socket_optint_option = | SO_LINGER Whether to linger on closed connections that have data present, and for how long (in seconds)
The socket options that can be consulted with getsockopt_optintsetsockopt_optintint option, with None meaning ``disabled''.
type socket_float_option = Unix.socket_float_option = | SO_RCVTIMEO Timeout for input operations
| SO_SNDTIMEO Timeout for output operations
The socket options that can be consulted with getsockopt_floatsetsockopt_float
Return the current status of a boolean-valued option in the given socket.
Set or clear a boolean-valued option in the given socket.
Same as getsockopt
Same as setsockopt
Same as getsockoptint option.
Same as setsockoptint option.
Same as getsockopt
Same as setsockopt
Return the error condition associated with the given socket, and clear it.
Connect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call Stdlib.flush
The two channels returned by open_connection share a descriptor to a socket. Therefore, when the connection is over, you should call Stdlib.close_outStdlib.close_in
``Shut down'' a connection established with open_connectionUnix.open_connection
Establish 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
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_outUnix.in_channel_of_descr
type protocol_entry = Unix.protocol_entry = { p_name : string; p_aliases : string array ; p_proto : int; } Structure of entries in the protocols database.
type service_entry = Unix.service_entry = { s_name : string; s_aliases : string array ; s_port : int; s_proto : string; } Structure of entries in the services database.
val gethostname : unit -> stringReturn the name of the local host.
Find an entry in hosts with the given name.
Find an entry in hosts with the given address.
Find an entry in protocols with the given name.
Find an entry in protocols with the given protocol number.
Find an entry in services with the given name.
Find an entry in services with the given service number.
type getaddrinfo_option = Unix.getaddrinfo_option = | AI_FAMILY of socket_domain Impose the given socket domain
| AI_SOCKTYPE of socket_type Impose the given socket type
| AI_PROTOCOL of intImpose the given protocol
| AI_NUMERICHOST Do not call name resolver, expect numeric IP address
| AI_CANONNAME Fill the ai_canonname field of the result
| AI_PASSIVE Set address to ``any'' address for use with bind
getaddrinfo host service opts returns a list of addr_infoopts 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
} type getnameinfo_option = Unix.getnameinfo_option = | NI_NOFQDN Do not qualify local host names
| NI_NUMERICHOST Always return host as IP address
| NI_NAMEREQD Fail if host name cannot be determined
| NI_NUMERICSERV Always return service as port number
| NI_DGRAM Consider the service as UDP-based instead of the default TCP
getnameinfo 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;mutable c_inpck : bool;Enable parity check on input.
mutable c_istrip : bool;Strip 8th bit on input characters.
mutable c_inlcr : bool;mutable c_igncr : bool;mutable c_icrnl : bool;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;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;mutable c_parenb : bool;Enable parity generation and detection.
mutable c_parodd : bool;Specify odd parity instead of even.
mutable c_hupcl : bool;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;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).
} Return the status of the terminal referred to by the given file descriptor.
Set 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 -> Send 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).
Waits until all output written on the given file descriptor has been transmitted.
Discard 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.
Suspend 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.
Put the calling process in a new session and detach it from its controlling terminal.
Untypeast (ocaml.Untypeast) Up – ocaml » UntypeastMap (ocaml.Var_within_closure.Map) Up – ocaml » Var_within_closure » MapModule Var_within_closure.Map include Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Var_within_closure.Set) Up – ocaml » Var_within_closure » SetModule Var_within_closure.Set include Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Var_within_closure.T) Up – ocaml » Var_within_closure » TModule Var_within_closure.T include Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Var_within_closure.Tbl) Up – ocaml » Var_within_closure » TblModule Var_within_closure.Tbl include Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Var_within_closure (ocaml.Var_within_closure) Up – ocaml » Var_within_closureModule 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.
include module type of Closure_element include Identifiable.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val unique_name : t -> Map (ocaml.Variable.Map) Up – ocaml » Variable » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Map (ocaml.Variable.Pair.Map) Up – ocaml » Variable » Pair » Mapinclude Map.S with type key = T.t and type 'a t = 'a Map.Make(T).t The type of the map keys.
The type of maps from type key to type 'a.
val add : key -> 'a -> 'a t -> 'a t add key data m returns a map containing the same bindings as m, plus a binding of key to data. If key was already bound in m to a value that is physically equal to data, m is returned unchanged (the result of the function is then physically equal to m). Otherwise, the previous binding of key in m disappears.
val add_to_list : key -> 'a -> 'a listt -> 'a listt add_to_list key data m is m with key mapped to l such that l is data :: Map.find key m if key was bound in m and [v] otherwise.
val update : key -> ('a option-> 'a option -> 'a t -> 'a t 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).
val singleton : key -> 'a -> 'a t singleton x y returns the one-element map that contains a binding y for x.
val remove : key -> 'a t -> 'a t remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map. If x was not in m, m is returned unchanged (the result of the function is then physically equal to m).
val merge :
+ (key -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f. In terms of the find_opt operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2) for any key x, provided that f x None None = None.
val union : (key -> 'a -> 'a -> 'a option -> 'a t -> 'a t -> 'a t union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2. When the same binding is defined in both arguments, the function f is used to combine them. This is a special case of merge: union f m1 m2 is equivalent to merge f' m1 m2, 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 v2val cardinal : 'a t -> Return the number of bindings of a map.
val bindings : 'a t -> (key * 'a ) listReturn the list of all bindings of the given map. The returned list is sorted in increasing order of keys with respect to the ordering Ord.compare, where Ord is the argument given to Map.Make.
val min_binding : 'a t -> key * 'a Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
val min_binding_opt : 'a t -> (key * 'a ) optionReturn the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.
val max_binding : 'a t -> key * 'a Same as min_binding
val max_binding_opt : 'a t -> (key * 'a ) optionSame as min_binding_opt
val choose : 'a t -> key * 'a Return one binding of the given map, or raise Not_found if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.
val choose_opt : 'a t -> (key * 'a ) optionReturn 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.
val find : key -> 'a t -> 'a find x m returns the current value of x in m, or raises Not_found if no binding for x exists.
val find_opt : key -> 'a t -> 'a optionfind_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.
val find_first : (key -> -> 'a t -> key * 'a 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.
val find_first_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val find_last : (key -> -> 'a t -> key * 'a 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.
val find_last_opt : (key -> -> 'a t -> (key * 'a ) optionfind_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.
val iter : (key -> 'a -> -> 'a t -> 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.
val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc 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.
val map : ('a -> 'b ) -> 'a t -> 'b t 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.
val mapi : (key -> 'a -> 'b ) -> 'a t -> 'b t Same as map
val filter : (key -> 'a -> -> 'a t -> 'a t 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)
val filter_map : (key -> 'a -> 'b option -> 'a t -> 'b t 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:
if f k v is None then k is not in the result, if 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.
val partition : (key -> 'a -> -> 'a t -> 'a t 'a t 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 split : key -> 'a t -> 'a t 'a option'a t 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.
val is_empty : 'a t -> Test whether a map is empty or not.
val mem : key -> 'a t -> mem x m returns true if m contains a binding for x, and false otherwise.
val equal : ('a -> 'a -> -> 'a t -> 'a t -> 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.
val compare : ('a -> 'a -> -> 'a t -> 'a t -> Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val for_all : (key -> 'a -> -> 'a t -> for_all f m checks if all the bindings of the map satisfy the predicate f.
val exists : (key -> 'a -> -> 'a t -> exists f m checks if at least one binding of the map satisfies the predicate f.
val to_list : 'a t -> (key * 'a ) listIterate on the whole map, in ascending order of keys
Iterate on the whole map, in descending order of keys
to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.
Add the given bindings to the map, in order.
Build a map from the given bindings
val of_list : (key * 'a ) list-> 'a t disjoint_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
val union_right : 'a t -> 'a t -> 'a t 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 union_left : 'a t -> 'a t -> 'a t union_left m1 m2 = union_right m2 m1
val union_merge : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t val map_keys : (key -> key ) -> 'a t -> 'a t val data : 'a t -> 'a listval transpose_keys_and_data : key t -> key t Set (ocaml.Variable.Pair.Set) Up – ocaml » Variable » Pair » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Variable.Pair.T) Up – ocaml » Variable » Pair » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Variable.Pair.Tbl) Up – ocaml » Variable » Pair » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Pair (ocaml.Variable.Pair) Up – ocaml » Variable » Pairinclude Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
Set (ocaml.Variable.Set) Up – ocaml » Variable » Setinclude Set.S with type elt = T.t and type t = Set.Make(T).t The type of the set elements.
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).
singleton x returns the one-element set containing only x.
val remove : elt -> t -> t 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).
val disjoint : t -> t -> Test if two sets are disjoint.
Set difference: diff s1 s2 contains the elements of s1 that are not in s2.
Return the number of elements of a set.
val elements : t -> elt listReturn 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 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.
val min_elt_opt : t -> elt optionReturn 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
val max_elt_opt : t -> elt optionSame as min_elt_opt
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.
val choose_opt : t -> elt optionReturn 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.
find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.
val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.
val find_first : (elt -> -> t -> elt 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.
val find_first_opt : (elt -> -> t -> elt optionfind_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.
val find_last : (elt -> -> t -> elt 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.
val find_last_opt : (elt -> -> t -> elt optionfind_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 iter : (elt -> -> t -> 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.
val fold : (elt -> 'acc -> 'acc ) -> t -> 'acc -> 'acc fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.
val filter : (elt -> -> t -> t 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).
val filter_map : (elt -> elt option -> t -> t 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.
val partition : (elt -> -> t -> t * t 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 split : elt -> t -> t * bool * t 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.
Test whether a set is empty or not.
val mem : elt -> t -> mem x s tests whether x belongs to the set s.
val equal : t -> t -> equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
val compare : t -> t -> Total ordering between sets. Can be used as the ordering function for doing sets of sets.
val subset : t -> t -> subset s1 s2 tests whether the set s1 is a subset of the set s2.
val for_all : (elt -> -> t -> for_all f s checks if all elements of the set satisfy the predicate f.
val exists : (elt -> -> t -> exists f s checks if at least one element of the set satisfies the predicate f.
val to_list : t -> elt listto_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.
Iterate on the whole set, in ascending order
Iterate on the whole set, in descending order
Add the given elements to the set, in order.
Build a set from the given bindings
val to_string : t -> val of_list : elt list-> t T (ocaml.Variable.T) Up – ocaml » Variable » Tinclude Hashtbl.HashedType with type t := t val equal : t -> t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := t val compare : t -> t -> 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
Tbl (ocaml.Variable.Tbl) Up – ocaml » Variable » Tblinclude Hashtbl.S with type key = T.t and type 'a t = 'a Hashtbl.Make(T).t val add : 'a t -> key -> 'a -> val remove : 'a t -> key -> val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a optionval find_all : 'a t -> key -> 'a listval replace : 'a t -> key -> 'a -> val mem : 'a t -> key -> val iter : (key -> 'a -> -> 'a t -> val filter_map_inplace : (key -> 'a -> 'a option -> 'a t -> val fold : (key -> 'a -> 'acc -> 'acc ) -> 'a t -> 'acc -> 'acc val to_list : 'a t -> (T.t * 'a ) listval of_list : (T.t * 'a ) list-> 'a t val memoize : 'a t -> (key -> 'a ) -> key -> 'a val map : 'a t -> ('a -> 'b ) -> 'b t Variable (ocaml.Variable) Up – ocaml » VariableModule 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.
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.S include Identifiable.Thing with type t := T.t include Hashtbl.HashedType with type t := T.t val equal : T.t -> T.t -> The equality predicate used to compare keys.
A 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 ((fun x y -> compare x y = 0), hashStdlib.nan ((==), hash include Map.OrderedType with type t := T.t val compare : T.t -> T.t -> 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
val create_with_same_name_as_ident : Ident.t -> t val unique_name : t -> val debug_when_stamp_matches : t -> stamp :int -> f :(unit -> unit) -> If the given variable has the given stamp, call the user-supplied function. For debugging purposes only.
val compare_lists : t list-> t list-> Unlike output, output_full includes the compilation unit.
Warnings (ocaml.Warnings) Up – ocaml » Warningsval ghost_loc_in_file : string -> loc Return an empty ghost range located in a given file
type field_usage_warning = | Unused | Not_read | Not_mutated type constructor_usage_warning = | Unused | Not_constructed | Only_exported_private type t = | 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| 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| 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_tailcall | Generative_application_expects_unit type alert = { kind : string; message : string; def : loc ; use : loc ; } val parse_options : bool -> string -> alert optionval parse_alert_option : string -> unitDisable/enable alerts based on the parameter to the -alert command-line option. Raises Arg.Bad if the string is not a valid specification.
val without_warnings : (unit -> 'a ) -> 'a Run the thunk with all warnings and alerts disabled.
val is_active : t -> val defaults_warn_error : stringval check_fatal : unit -> unitval reset_fatal : unit -> unitval help_warnings : unit -> unitval backup : unit -> state val restore : state -> val with_state : state -> (unit -> 'a ) -> 'a Like Lazy.of_fun, but the function is applied with the warning/alert settings at the time mk_lazy is called.
X86_ast (ocaml.X86_ast) Up – ocaml » X86_astD (ocaml.X86_dsl.D) Up – ocaml » X86_dsl » DModule X86_dsl.D Directives
val bytes : string -> unitval cfi_adjust_cfa_offset : int -> unitval cfi_endproc : unit -> unitval cfi_startproc : unit -> unitval cfi_remember_state : unit -> unitval cfi_restore_state : unit -> unitval cfi_def_cfa_register : string -> unitval cfi_def_cfa_offset : int -> unit
val file : file_num :int -> file_name :string -> val global : string -> unitval indirect_symbol : string -> unitval loc : file_num :int -> line :int -> col :int -> val mode386 : unit -> unitval model : string -> unitval private_extern : string -> unitval section : string list -> string option -> string list -> val type_ : string -> string -> unitI (ocaml.X86_dsl.I) Up – ocaml » X86_dsl » Ival fcompp : unit -> unitval fldlg2 : unit -> unitval fldln2 : unit -> unitval fpatan : unit -> unitX86_dsl (ocaml.X86_dsl) Up – ocaml » X86_dslX86_gas (ocaml.X86_gas) Up – ocaml » X86_gasX86_masm (ocaml.X86_masm) Up – ocaml » X86_masmX86_proc (ocaml.X86_proc) Up – ocaml » X86_procHelpers for textual emitters
val string_of_string_literal : string -> stringval string_of_symbol : string -> string -> stringBuffer of assembly code
val reset_asm_code : unit -> unitCode emission
Post-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).
val assemble_file : string -> string -> intGenerate 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
type system = | S_macosx | S_gnu | S_cygwin | S_solaris | S_win32 | S_linux_elf | S_bsd_elf | S_beos | S_mingw | S_win64 | S_linux | S_mingw64 | S_freebsd | S_netbsd | S_openbsd | S_unknown Whether calls need to go via the PLT.
Support for plumbing a binary code emitter
val with_internal_assembler :
+ (X86_ast.asm_program -> string -> unit) -> (unit -> 'a ) -> 'a ' information to compiler warnings.
+ (André Maroneze, review by Florian Angeletti and Gabriel Scherer)
+
+- #10909: Disable warning 59 (assignment to immutable blocks) unless flambda
+ invariant checks are enabled.
+ (Vincent Laviron, review by Gabriel Scherer)
+
+- #10981, #11276: Implement a -cmi-file option for ocamlc and ocamlopt.
+ (Sébastien Hinderer, review by Damien Doligez, Daniel Bünzli and
+ Florian Angeletti)
+
+* #11049: Stop padding 1-digit compiler minor version numbers.
+ (So for instance OCaml 5.0 rather than 5.00)
+ (Sébastien Hinderer, review by David Allsopp, Florian Angeletti and
+ Xavier Leroy)
+
+- #11184, #11670: Stop calling ranlib on created / installed libraries
+ (Sébastien Hinderer and Xavier Leroy, review by the same)
+
+- #11253: Deprecate `ocaml script` and `ocamlnat` script where `script` has no
+ extension and is an implicit basename.
+ (David Allsopp, review by Florian Angeletti and Sébastien Hinderer)
+
+### Internal/compiler-libs changes:
+
+- #10878, #10909: restore flambda after the Multicore merge.
+ (Vincent Laviron, review by Gabriel Scherer and Xavier Leroy)
+
+- #10864, #10888: restore afl-fuzz mode for sequential programs.
+ (Jan Midtgaard, review by Xavier Leroy and Gabriel Scherer)
+
+- #11008, #11047: rework GC statistics in the Multicore runtime
+ (Gabriel Scherer, review by Enguerrand Decorne)
+
+- #11058: basic debugging documentation in runtime/HACKING.adoc
+ (Gabriel Scherer, review by Enguerrand Decorne and Nicolás Ojeda Bär)
+
+- #11199: Stop installing topdirs.cmi twice. The toplevel now reads topdirs.cmi
+ from +compiler-libs, as the debugger does.
+ (David Allsopp, review by Sébastien Hinderer)
+
+- #11007, #11399: META files for the stdlib, compiler-libs and other libraries
+ (unix, dynlink, str, runtime_events, threads, ocamldoc) are now installed
+ along with the compiler.
+ (David Allsopp, Florian Angeletti, Nicolás Ojeda Bär and Sébastien Hinderer,
+ review by Daniel Bünzli, Kate Deplaix, Anil Madhavapeddy and Gabriel Scherer)
+
+### Build system:
+
+* #10893: Remove configuration options --disable-force-safe-string and
+ DEFAULT_STRING=unsafe as well as --enable-force-safe-string and
+ DEFAULT_STRING=safe which are now the default unconditionally.
+ (Kate Deplaix, review by Gabriel Scherer and David Allsopp)
+
+- #11092: Build native-code compilers on OpenBSD/aarch64.
+ (Christopher Zimmermann, review by Anil Madhavapeddy)
+
+- #11126: Build system: make it possible to choose which ocamldep
+ (and flags) to use when computing dependencies for the compiler.
+ Add a -no-slash option to ocamldep to let users override -slash.
+ (Sébastien Hinderer, review by David Allsopp)
+
+- #11147: Factorize the stdlib-related compilation flags. Make it
+ possible to control them consistently through the STDLIBFLAGS
+ build variable. Make sure ocamldoc and ocamllex get compiled and
+ linked with debugging information (-g).
+ (Sébastien Hinderer, review by Gabriel Scherer)
+
+- #11149: Make the bootstrap process reproducible on systems with non-big-endian
+ floating point. If the boot/ artefacts are up-to-date, this means that running
+ make bootstrap on any platform should not change the images in boot/ and paves
+ the way for automated testing that the bootstrap is repeatable.
+ (David Allsopp, review by Damien Doligez and Sébastien Hinderer)
+
+- #11160: otherlibs: merge win32unix into unix.
+ (Sébastien Hinderer, review by David Allsopp, Nicolás Ojeda Bär,
+ Xavier Leroy, Vincent Laviron and Antonin Décimo)
+
+* #11198, #11298: Install the Dynlink, Str and Unix libraries to individual
+ subdirectories of LIBDIR. The compiler, debugger and toplevel automatically
+ add `-I +lib` if required, but display an alert.
+ (David Allsopp, review by Florian Angeletti, Nicolás Ojeda Bär,
+ Valentin Gatien-Baron and Sébastien Hinderer)
+
+- #11200: Install ocamlprof's Profiling runtime module to a +profiling,
+ removing it from the default namespace.
+ (David Allsopp, review by Sébastien Hinderer)
+
+- #11294: Switch minimum required autoconf to 2.71.
+ (David Allsopp, review by Xavier Leroy)
+
+- #11370, #11373: Don't pass CFLAGS to flexlink during configure.
+ (David Allsopp, report by William Hu, review by Xavier Leroy and
+ Sébastien Hinderer)
+
+- #11487: Thwart FMA test optimization during configure
+ (William Hu, review by David Allsopp and Sébastien Hinderer)
+
+- #11097: Build native-code compilers on NetBSD/aarch64
+ (Kate Deplaix, review by Anil Madhavapeddy)
+
+### Bug fixes:
+
+- #10768, #11340: Fix typechecking regression when combining first class
+ modules and GADTs.
+ (Jacques Garrigue, report by François Thiré, review by Matthew Ryan)
+
+- #10790: don't drop variance and injectivity annotations when pretty printing
+ `with` constraints (for example, `with type +!'a t = ...`).
+ (Florian Angeletti, report by Luke Maurer, review by Matthew Ryan and
+ Gabriel Scherer)
+
+- #11167: Fix memory leak from signal stack.
+ (Antoni Żewierżejew, review by Gabriel Scherer and Enguerrand Decorne)
+
+- #11112: harden -use-runtime against spaces or quotes in the provided path
+ (Gabriel Scherer, report by Brahima Dibassi, review by David Allsopp)
+
+- #11068, #11070: Fix typo in function name given in Unix_error exception for
+ Unix.readlink on Windows.
+ (David Allsopp, report by Xia Li-yao)
+
+- #10807: Don't duplicate standard handles in the child process
+ spawned by win32unix Unix.create_process if the handles were already
+ inheritable. Fix broken signalling of EOF on standard handles if
+ they were already inheritable.
+ (Antonin Décimo, review by Xavier Leroy and Nicolás Ojeda Bär)
+
+- #10868: Fix off-by-1 bug when initializing frame hashtables
+ (Jonah Beckford, review by Tom Kelly, Nicolás Ojeda Bär and
+ KC Sivaramakrishnan)
+
+- #11077: Make dumpobj compatible with absence of naked pointer support
+ (Olivier Nicole and Jan Midtgaard, review by Gabriel Scherer)
+
+- #11111: fix fork() usage in ocamltest C code.
+ When calling fork() from C code with the Multicore runtime active,
+ one needs to call caml_atfork_hook() on the forked child before it
+ can use the OCaml runtime.
+ (Gabriel Scherer, review by Xavier Leroy, report by Brahima Dibassi)
+
+- #10809: Use the WSA_FLAG_NO_HANDLE_INHERIT on Windows when creating
+ sockets with WSASocket if the cloexec (non-inheritable) parameter is
+ true. Fixes a race condition where a child process could inherit the
+ socket and deadlock the parent.
+ (Antonin Décimo, review by Xavier Leroy)
+
+- #11194, #11609: Fix inconsistent type variable names in "unbound type var"
+ messages
+ (Ulysse Gérard and Florian Angeletti, review Florian Angeletti and
+ Gabriel Scherer)
+
+- #11204: Fix regression introduced in 4.14.0 that would trigger Warning 17 when
+ calling virtual methods introduced by constraining the self type from within
+ the class definition.
+ (Nicolás Ojeda Bär, review by Leo White)
+
+- #11263, #11267: caml/misc.h: check whether `_MSC_VER` is defined before using
+ it to ensure that the headers can always be used in code which turns on
+ -Wundef (or equivalent).
+ (David Allsopp and Nicolás Ojeda Bär, review by Nicolás Ojeda Bär and
+ Sébastien Hinderer)
+
+- #11289, #11405: fix some leaks on systhread termination
+ (Fabrice Buoro, Enguerrand Decorne, Gabriel Scherer,
+ review by Xavier Leroy and Florian Angeletti, report by Romain Beauxis)
+
+- #11314, #11416: fix non-informative error message for module inclusion
+ (Florian Angeletti, report by Thierry Martinez, review by Gabriel Scherer)
+
+- #11358, #11379: Refactor the initialization of bytecode threading,
+ This avoids a "dangling pointer" warning of GCC 12.1.
+ (Xavier Leroy, report by Armaël Guéneau, review by Gabriel Scherer)
+
+- #11387, module type with constraints no longer crash the compiler in presence
+ of both shadowing warnings and the `-bin-annot` compiler flag.
+ (Florian Angeletti, report by Christophe Raffalli, review by Gabriel Scherer)
+
+- #11392, #11392: assertion failure with -rectypes and external definitions
+ (Gabriel Scherer, review by Florian Angeletti, report by Dmitrii Kosarev)
+
+- #11417: Fix regression allowing virtual methods in non-virtual classes.
+ (Leo White, review by Florian Angeletti)
+
+- #11468: Fix regression from #10186 (OCaml 4.13) detecting IPv6 on Windows for
+ mingw-w64 i686 port.
+ (David Allsopp, review by Xavier Leroy and Sébastien Hinderer)
+
+- #11482, #11542: Fix random crash in large closure allocation
+ (Damien Doligez, report by Thierry Martinez and Vincent Laviron, review by
+ Xavier Leroy)
+
+- #11508, #11509: make Bytes.escaped domain-safe
+ (Christiano Haesbaert and Gabriel Scherer,
+ review by Xavier Leroy,
+ report by Jan Midtgaard and Tom Kelly)
+
+- #11516, #11524: Fix the `deprecated_mutable` attribute.
+ (Chris Casinghino, review by Nicolás Ojeda Bär and Florian Angeletti)
+
+- #11576: Fix bug in Bigarray.Genarray.init in the the case of zero-dimensional
+ arrays.
+ (Nicolás Ojeda Bär, Jeremy Yallop, report by Masayuki Takeda, review by Jeremy
+ Yallop and Florian Angeletti)
+
+- #11587: Prevent integer comparison from being used on pointers
+ (Vincent Laviron, review by Gabriel Scherer)
+
+- #11622: Prevent stack overflow when printing a constructor or record
+ mismatch error involving recursive types.
+ (Florian Angeletti, review by Gabriel Scherer)
+
+- #11662, #11673: fix a memory leak when using Dynlink,
+ the bug was only present in development version of OCaml 5.
+ (Stephen Dolan, report by Andre Maroneze, review by Gabriel Scherer)
+
+- #11732: Ensure that types from packed modules are always generalised
+ (Stephen Dolan and Leo White, review by Jacques Garrigue)
+
+- #11737: Fix segfault condition in Unix.stat under Windows in the presence of
+ multiple threads.
+ (Marc Lasson, Nicolás Ojeda Bär, review by Gabriel Scherer and David Allsopp)
+
+- #11776: Extend environment with functor parameters in `strengthen_lazy`.
+ (Chris Casinghino and Luke Maurer, review by Gabriel Scherer)
+
+- #11533, #11534: follow synonyms again in #show_module_type
+ (this had stopped working in 4.14.0)
+ (Gabriel Scherer, review by Jacques Garrigue and Florian Angeletti,
+ report by Yaron Minsky)
+
+OCaml 4.14.0 (28 March 2022)
+----------------------------
+
+### Language features:
+
+- #10462: Add attribute to produce a compiler error for polls.
+ (Sadiq Jaffer, review by Mark Shinwell, Stephen Dolan
+ and Guillaume Munch-Maccagnoni)
+
+- #10437: Allow explicit binders for type variables.
+ (Stephen Dolan, review by Leo White)
+
+- #10441: Remove unnecessary parentheses surrounding immediate objects.
+ Allow 'object ... end # f', 'f object ... end', etc.
+ (Yan Dong, review by Nicolás Ojeda Bär, Florian Angeletti and Gabriel Scherer)
+
+- #181, #9760, #10740: opt-in tail-modulo-cons (TMC) transformation
+ let[@tail_mod_cons] rec map f li = ...
+ (Frédéric Bour, Gabriel Scherer, Basile Clément,
+ review by Basile Clément and Pierre Chambart,
+ tested by Konstantin Romanov)
+
+### Runtime system:
+
+* #9391, #9424: Fix failed assertion in runtime due to ephemerons *set_* and
+ *blit_* function during Mark phase
+ (François Bobot, reported by Stephen Dolan, reviewed by Damien Doligez)
+
+- #10195, #10680: Speed up GC by prefetching during marking
+ (Stephen Dolan, review by Xavier Leroy, Guillaume Munch-Maccagnoni,
+ Jacques-Henri Jourdan, Damien Doligez and Leo White)
+
+- #10549: Stack overflow detection and naked pointers checking for ARM64
+ (Xavier Leroy, review by Stephen Dolan)
+
+* #10675: Emit deprecation warnings when old C runtime function names
+ are used. This will break C stub code that uses these old names and
+ treats warnings as errors. The workaround is to use the new names.
+ (Xavier Leroy and David Allsopp, review by Sébastien Hinderer and
+ Damien Doligez)
+
+- #10698, #10726: Free the alternate signal stack when the main OCaml
+ code or an OCaml thread stops
+ (Xavier Leroy, review by David Allsopp and Damien Doligez)
+
+- #10730, 10731: Fix bug in `Obj.reachable_words` causing a slowdown when called
+ multiple time (Alain Frisch, report by ygrek, review by Xavier Leroy)
+
+- #10926: Rename the two internal Windows Unicode functions with `caml_` prefix
+ instead of `win_`.
+ (David Allsopp, review by Kate Deplaix, Damien Doligez and Xavier Leroy)
+
+### Code generation and optimizations:
+
+- #10578: Increase the number of integer registers used for
+ parameter passing on PowerPC (16 registers) and on s390x (8 registers).
+ (Xavier Leroy, review by Mark Shinwell)
+
+- #10591, #10615: Tune the heuristic for CSE of integer constants
+ so as to avoid excessive CSE on compiler-generated constants
+ and long register allocation times.
+ (Xavier Leroy, report by Edwin Török, review by Nicolás Ojeda Bär)
+
+- #10595: Tail calls with up to 64 arguments are guaranteed to be compiled
+ as tail calls. To this end, memory locations in the domain state
+ are used for passing arguments that do not fit in registers.
+ (Xavier Leroy, review by Vincent Laviron)
+
+- #10681: Enforce boolean conditions for the native backend
+ (Vincent Laviron, review by Gabriel Scherer)
+
+- #10719: Ensure that build_apply respects Lambda.max_arity
+ (Stephen Dolan, review by Xavier Leroy)
+
+- #10728: Ensure that functions are evaluated after their arguments
+ (Stephen Dolan, review by Mark Shinwell)
+
+- #10732: Ensure right-to-left evaluation of arguments in cmm_helpers
+ (Greta Yorsh, review by Xavier Leroy)
+
+### Standard library:
+
+* #10710: Add UTF tools, codecs and validations to the Uchar, Bytes and
+ String modules.
+ (Daniel Bünzli, review by Florian Angeletti, Nicolás Ojeda Bär, Alain
+ Frisch and Gabriel Scherer)
+
+* #10622: Annotate `Uchar.t` with immediate attribute
+ (Hongbo Zhang, reivew by Gabriel Scherer and Nicolás Ojeda Bär)
+
+* #7812, #10475: `Filename.chop_suffix name suff` now checks that `suff`
+ is actually a suffix of `name` and raises Invalid_argument otherwise.
+ (Xavier Leroy, report by whitequark, review by David Allsopp)
+
+* #10482: mark the Stream and Genlex modules as deprecated, in preparation
+ for a future removal. These modules (without deprecation alert)
+ are now provided by the camlp-streams library.
+ (Xavier Leroy, review by Nicolás Ojeda Bär)
+
+- #10526: add Random.bits32, Random.bits64, Random.nativebits
+ (Xavier Leroy, review by Gabriel Scherer and François Bobot)
+
+* #10568: remove Obj.marshal and Obj.unmarshal
+ (these functions have been deprecated for a while and are superseded
+ by the functions from module Marshal)
+ (François Pottier, review by Gabriel Scherer and Kate Deplaix)
+
+- #10545: Add In_channel and Out_channel modules.
+ (Nicolás Ojeda Bär, review by Daniel Bünzli, Simon Cruanes, Gabriel Scherer,
+ Guillaume Munch-Maccagnoni, Alain Frisch and Xavier Leroy)
+
+- #10538: add Out_channel.set_buffered and Out_channel.is_buffered to control
+ the buffering mode of output channels.
+ (Nicolás Ojeda Bär, review by John Whitington, Daniel Bünzli, David Allsopp
+ and Xavier Leroy)
+
+* #10583, #10998: Add over 40 new functions in Seq.
+ (François Pottier and Simon Cruanes, review by Nicolás Ojeda Bär,
+ Daniel Bünzli, Naëla Courant, Craig Ferguson, Wiktor Kuchta,
+ Xavier Leroy, Guillaume Munch-Maccagnoni, Raphaël Proust, Gabriel Scherer
+ and Thierry Martinez)
+
+- #10596, #10978: Add with_open_bin, with_open_text and with_open_gen to
+ In_channel and Out_channel. Also, add In_channel.input_all.
+ (Nicolás Ojeda Bär, review by Daniel Bünzli, Jérémie Dimino, Damien Doligez
+ and Xavier Leroy)
+
+- #10658: add detailed information about the current version of OCaml
+ to the Sys module of the standard library.
+ (Sébastien Hinderer, review by Damien Doligez, Gabriel Scherer, David
+ Allsopp, Nicolás Ojeda Bär, Vincent Laviron)
+
+- #10642: On Windows, Sys.remove and Unix.unlink now remove symlinks
+ to directories instead of raising EACCES. Introduce
+ caml/winsupport.h to hold more common code between the runtime,
+ lib-sys, and win32unix.
+ (Antonin Décimo, review by David Allsopp and Xavier Leroy)
+
+- #10737: add new ephemeron API for forward compatibility with Multicore
+ OCaml.
+ (Damien Doligez, review by Stephen Dolan)
+
+- #10786: The implementation of Complex.norm now uses Float.hypot.
+ (Christophe Troestler, review by David Allsopp and Xavier Leroy)
+
+### Other libraries:
+
+- #10192: Add support for Unix domain sockets on Windows and use them
+ to emulate Unix.socketpair (only available on Windows 1803+)
+ (Antonin Décimo, review by David Allsopp)
+
+- #10469: Add Thread.set_uncaught_exception_handler and
+ Thread.default_uncaught_exception_handler.
+ (Enguerrand Decorne, review by David Allsopp)
+
+- #10697: Bindings of dup and dup2 in win32unix now correctly call
+ WSADuplicateSocket on sockets instead of DuplicateHandle.
+ (Antonin Décimo, review by Xavier Leroy and Nicolás Ojeda Bär)
+
+* #10926, #11336: Ensure all C functions in the Unix library are prefixed with
+ `caml_`.
+ (David Allsopp, review by Kate Deplaix, Damien Doligez and Xavier Leroy)
+
+- #10951: Introduce the Thread.Exit exception as an alternative way to
+ terminate threads prematurely. This alternative way will become
+ the standard way in 5.0.
+ (Xavier Leroy, review by Florian Angeletti)
+
+### Tools:
+
+- #9701: Release bytecode only after collecting backtrace information
+ for exceptions, same for dynamic loaded code compiled from toplevel on
+ ocamlnat.
+ (Renato Alencar, reported by Krzysztof Leśniak, reviewed by Gabriel Scherer)
+
+- #10839: Fix regression of #show when printing class type
+ (Élie Brami, review by Florian Angeletti)
+
+- #3959, #7202, #10476: ocaml, in script mode, directive errors
+ (`#use "missing_file";;`) use stderr and exit with an error.
+ (Florian Angeletti, review by Gabriel Scherer)
+
+- #10438: add a new toplevel cli argument `-e Up – ocamlEventFirst-class synchronous communication. ThreadLightweight threads for Posix 1003.1c and Win32. Afl_instrumentInstrumentation for afl-fuzz. Alias_analysisAllocated_constConstants that are always allocated (possibly statically). Blocks are not included here since they are always encoded using Prim (Pmakeblock, ...). AnnotArchArg_helperDecipher command line arguments of the form <value> | <key>=<value>,... AsmgenFrom Lambda to assembly code AsmlibrarianAsmlinkAsmpackagerAst_helperHelpers to produce Parsetree fragments Ast_invariantsCheck AST invariants Ast_iteratorAst_iterator.iteratorAst_iterator.default_iteratorAst_mapperThe interface of a -ppx rewriter AsttypesAuxiliary AST types used by parsetree and typedtree. Attr_helperHelpers for attributes Augment_specialised_argsHelper module for adding specialised arguments to sets of closures. Backend_intfKnowledge that the middle end needs about the backend. Backend_varVariables used in the backend, optionally equipped with "provenance" information, used for the emission of debugging information. BinutilsBranch_relaxationBranch_relaxation_intfBtypeBuild_export_infoConstruct export information, for emission into .cmx files, from an Flambda program. Build_path_prefix_mapRewrite paths for reproducible builds Builtin_attributesSupport for some of the builtin attributes BytegenBytelibrarianBytelinkBytepackagerBytesectionsCSECommon interface to all architecture-specific CSE modules CSEgenCamlinternalMenhirLibCcompCompiling C files and building C libraries ClambdaClambda_primitivesClflagsCommand line flags ClosureClosure_conversionClosure_conversion_auxEnvironments and auxiliary structures used during closure conversion. Closure_elementClosure_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. Closure_middle_endClosure_offsetsAssign numerical offsets, within closure blocks, for code pointers and environment entries. Closure_originCmi_formatCmmCmm_helpersCmm_invariantsCheck a number of continuation-related invariants CmmgenCmmgen_stateMutable state used by Cmmgen. Cmo_formatCmt2annotCmt_formatcmt and cmti files format. Cmx_formatCmxs_formatColoringComballocCompenvCompilation_unitCompileBytecode compilation for .ml and .mli files. Compile_commonCommon compilation pipeline between bytecode and native. CompilenvCompmiscCompressionConfigSystem configuration Config_bootSystem configuration Config_mainSystem configuration ConsistblConsistency tables: for checking consistency of module CRCs Convert_primitivesCtypeDataflowDatareprDeadcodeDebuginfoDependModule dependencies. DiffingParametric diffing Diffing_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. DllDocstringsDocumentation comments DomainstateEffect_analysisSimple side effect analysis. EmitEmitauxEmitcodeEmitenvEnvEnvauxErrorsErrortraceExport_idExport_infoExported information (that is to say, information written into a .cmx file) about a compilation unit. Export_info_for_packTransformations on export information that are only used for the building of packs. ExpungeExtract_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. Find_recursive_functions"Recursive functions" are those functions f that might call either: FlambdaIntermediate language used for tree-based analysis and optimization. Flambda_invariantsFlambda_iteratorsFlambda_middle_endTranslate Lambda code to Flambda code, optimize it, and produce Clambda. Flambda_to_clambdaFlambda_utilsUtility functions for the Flambda intermediate language. FresheningFreshening of various identifiers. GenprintvalId_typesIdentIdentifiableUniform interface for common data structures over various things. Import_approxCreate simple value approximations from the export information in .cmx files. IncludeclassIncludecoreIncludemodIncludemod_errorprinterInconstant_identsInitialize_symbol_to_let_symbolInline_and_simplifyInline_and_simplify_auxEnvironments and result structures used during inlining and simplification. (See inline_and_simplify.ml.) Inlining_costMeasurement of the cost (including cost in space) of Flambda terms in the context of inlining. Inlining_decisionSee the Flambda manual chapter for an explanation in prose of the inlining decision procedure. Inlining_decision_intfInlining_statsInlining_stats_typesInlining_transformsSource code transformations used during inlining. InstructInt_replace_polymorphic_compareInterfInternal_variable_namesIntervalInvariant_paramsLambdaLazy_backtrackLexerThe lexical analyzer Lift_codeLift_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. Lift_let_to_initialize_symbolLinearLinear_formatLinearizeLinkage_nameLinscanLivenessLoad_pathManagement of include directories. Local_storeThis module provides some facilities for creating references (and hash tables) which can easily be snapshoted and restored to an arbitrary version. LocationSource code locations (ranges of positions), used in parsetree. LongidentLong identifiers, used in parsetree. MachMainMain_argsMaindriverMakedependMatchingMetaMiscMiscellaneous useful types and functions MtypeMutable_variableNumbersModules about numbers, some of which satisfy Identifiable.S OpcodesOprintOptcompileNative compilation for .ml and .mli files. OpterrorsOptmainOptmaindriverOutcometreeParameterParameter.t carries a unique Variable.t used as function parameter. It can also carry annotations about the usage of the variable.ParmatchDetection of partial matches and unused match cases. ParseEntry points in the parser ParserParsetreeAbstract syntax tree produced by parsing Pass_wrapperPathPatternsPersistent_envPollingAnalyses related to the insertion of Ipoll operations. PparseDriver for the parser and external preprocessors. PprintastPretty-printers for Parsetree PredefPrimitivePrintastRaw printer for Parsetree PrintclambdaPrintclambda_primitivesPrintcmmPrintinstrPrintlambdaPrintlinearPrintmachPrintpatPrinttypPrinttypedProcProfileCompiler performance recording ProjectionRepresentation of projections from closures and blocks. Rec_checkRef_to_variablesTransform let-bound references into variables. RegReloadReloadgenRemove_free_vars_equal_to_argsReplace free variables in closures known to be equal to specialised arguments of such closures with those specialised arguments. Remove_unused_argumentsRemove_unused_closure_varsRemove_unused_program_constructsRuntimedefSchedgenSchedulingSelectgenSelectionSemantics_of_primitivesDescription of the semantics of primitives, to be used for optimization purposes. Set_of_closures_idAn identifier, unique across the whole program, that identifies a set of closures (viz. Set_of_closures). Set_of_closures_originShapeShare_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 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. SimplifLambda simplification. Simplify_boxed_integer_opsSimplify_boxed_integer_ops_intfSimplify_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.Simplify_primitivesSpillSplitStatic_exceptionAn identifier that is used to label static exceptions. Its uniqueness properties are unspecified. StrmatchStrongly_connected_componentsKosaraju's algorithm for strongly connected components. StypesSubstSwitchSymbolA symbol identifies a constant provided by either: SymtableSyntaxerrAuxiliary type for reporting syntax errors TagTags on runtime boxed values. TargetintTarget processor-native integers. Tast_iteratorAllows the implementation of typed tree inspection using open recursion Tast_mapperTerminfoBasic interface to the terminfo database TmcTail-modulo-cons optimization. TopcommonThis module provides common implementations for internals of Toploop, for bytecode and native code (see Topeval for the diverging parts of the implementation). TopdirsTopevalThis module provides two alternative implementations for internals of Toploop, for bytecode and native code. TophooksToploopTopmainTopprintersTopstartTraceTranslattributeTranslclassTranslcoreTranslmodTranslobjTranslprimTraverse_for_exported_symbolsType_immediacyImmediacy status of a type TypeclassTypecoreTypedeclTypedecl_immediacyTypedecl_propertiesTypedecl_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. Typedecl_unboxedTypedecl_varianceTypedtreeAbstract syntax tree after typing TypemodType-checking of the module language and typed ast hooks TypeoptTypesTypetexpUn_anfUnbox_closuresTurn free variables of closures into specialised arguments. The aim is to cause the closure to become closed. Unbox_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. Unbox_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. UntypeastVar_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. VariableVariable.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.WarningsWarning definitions X86_astStructured representation of Intel assembly language (32 and 64 bit). X86_dslHelpers for Intel code generators X86_gasEmit assembly instructions for gas. X86_masmEmit assembly instructions for MASM (Intel syntax). X86_procDefinitions shared between the 32 and 64 bit Intel backends.